malvasia bianca

At work, we frequently play a few rounds of Burnout Revenge after lunch. (Video games seem to be a general startup thing, not just a game startup thing.) Which is a lot of fun; the only Burnout game I’d previously played was Burnout Paradise, and while I think that game is a masterpiece, I’m also under the impression that it’s quite different from its predecessors, so I was happy to have an excuse to try another entry in the series.

It took me several weeks of lunchtime matches to get used to the feel of driving in the game, but I have the basics under my belt now. And now that I’m somewhat competent at the game, I’m finding that the game gives me a rather different feel from other racing games that I’m used to: decisions in it can, in large part, be interpreted as being about risk management.

The distinguishing feature of Burnout Revenge (compared to others in the racing genre) is its use of traffic. There’s a lot of traffic; but you can plow right through cars going in the same direction as you (in fact, it fills up your boost meter, helping you go faster), while if you run into traffic going in the opposite direction (or, more rarely, cross traffic), you’ll crash. And you’ll also crash if you hit very large vehicles (buses, generally) going in the same direction as yourself.

Most of the time, this means that you stay in the correct lane, plowing through cars to fill up your boost. But if I’ve got a fair amount of visibility and not many cars to run into in my direction, I’ll move to the other side of the road, because you also earn boost if you’re going against traffic. (Going against traffic even if the lane isn’t empty is far from a death penalty, but it does increase your risk noticeably.)

It gets interesting, though, when you come to a turn. In a normal racing game, you want to approach a turn from a line designed to let you maintain as high a speed as possible. In Burnout, however, the distinguishing characteristic of turns is that they have a different risk profile. You have traffic approaching the intersection from multiple directions; if you’re making a left turn (or a right turn in the Tokyo/Hong Kong courses), you’ll always be crossing lanes that may contain approaching traffic, and even if you’re making a right turn, if you maintain any sort of decent speed, you’ll almost certainly slide into the left lane after the turn. (And if you approach from the best line from a pure racing perspective, you’d also want to switch over to the left lane before a right turn.) You can mitigate some of that (for right turns, at least) by sliding, but unless you’re better at sliding than I am, you’ll still fishtail enough while doing so to end up in the oncoming lane even while making a right turn. (This also applies when going around switchbacks on mountain courses, even without cross traffic.)

The result is that, when approaching a turn, I don’t think “how can I get through this at as high speed as possible?” Instead, I think “how can I maximize the number of options that I have, in order to react to surprises in traffic conditions?” Assuming it’s a left turn, I’ll rarely want to cut the corner sharply: if I do that, I’ll be in the oncoming lane with absolutely no information about what cars are there, so it’s a roll of the dice as to whether or not I’ll survive. Instead, I want to position myself so that I’ll get a good view of the oncoming traffic as early as possible, so I’ll have a few more tenths of a second to react to the conditions and plot a course to thread through traffic. Though, of course, the traffic as I approach the intersection may make that impossible: if that’s the case, I have to figure out how to avoid the oncoming cars that I can see (or the buses going in my direction) while getting a view of what’s approaching as early as possible.

This also plays into the design of shortcuts. There are a lot of them, and they often have traditional sorts of shortcut dangers: there might be jumps that are hard to make, or pillars to thread your way through. So their presence puts a premium on both course knowledge and driving skill.

What the shortcuts don’t have is traffic. Which can actually be a bit of a bummer, because if you’re low on boost, you may wish that you had more cars to run into, or oncoming lanes to cross into! But it gives the risk profile a quite different feel.

Except: occasionally they do have traffic. Some of the shortcuts lead you through alleys in the middle of blocks: so no traffic most of the time, but then you’ll blow through a street and be exposed to cross traffic. Even in the best such situations, you have very little time to react, and if a bus shows up at the wrong time, you’ll almost certainly crash no matter how good a driver you are.

The ends of shortcuts are also quite dangerous. They’ll dump you on a road, but they’ll frequently drop you on the wrong side of the road, without much time to react to oncoming traffic. That’s not as dangerous as cross traffic, but it’s still significantly more dangerous than a normal turn is. And it certainly puts a premium on your ability to parse a situation quickly: my improvement in that regard has been a bigger help in my recent increased competitiveness than my learning about the track layout.

So the upshot: shortcuts are generally shorter (duh) but tricker to navigate (which is normal in a racing game), but they also lead to riskier interactions with traffic at their ends and in street crossings in their middle (which is less common in a racing game). They’re still generally worth it, but you’re trading off better average returns for increased variance. Which makes the game more fun from a multiplayer point of view: your preferred amount of risk will change depending on your position in the race, and increasing randomness (within reasonable bounds) lets the best player win most of the time while increasing the chance of close races and upsets.

Fun game.

When Apple released a version of iOS with a limited form of multitasking, they also added a way to switch directly between apps by double-tapping the home screen. I almost never used that feature, however—I don’t have so many apps on my phone that it’s hard for me to get to the one I want through the home screens, and in particular the ones that are on my first screen are there exactly because I use them so often! (The main time that I drop into the “view recent apps” mode is to kill Mail to force it to resync my mailbox, which I have to do surprisingly often.)

A few weeks ago, though, I tried using double-tapping to switch between applications; and, to my surprise, I found that I rather liked it. In fact, I found that, when I’m switching applications that way, it feels like the machine really is multitasking: going to the home screen triggers an “exiting an app” feeling in my brain, while double-tapping to switch triggers a “switching between active apps” feeling in my brain.

Which is, I realize, kind of ridiculous: I am quite aware that there’s nothing different going on in those two scenarios. Brains are funny things, though, and it behooves us to design interfaces with that funniness in mind!

(Incidentally, this change in habits makes me wish that I had a case that didn’t cover the home button, because the case makes the button mushy enough that I can’t reliably double-tap. Definitely something to avoid next time; I may well go without a case at all next time, both because of this and to better appreciate Apple’s industrial design.)

Another way to look at what I was saying yesterday about Tiny Wings: the game says that your actions matter (even if those “actions” consist solely of deciding when to touch the screen!), that they’re worth focusing on and honing, and the game goes to quite some length to actively support you in that journey. In fact, Tiny Wings, despite its single-button controls, rather reminds me of Rock Band 3 in that regard: as I’ve said before, Rock Band 3 concentrates wonderfully on small segments of gameplay, saying that getting them right is worth striving towards, and helping you do just that.

I also want to use this as an excuse to plug Pippin Barr’s blog inininoutoutout. He talks about learning a lot: most recently in his extolling GIRP, but also in his advocacy of Skate 3. I really have to play that game at some point: the only thing that’s holding me back is that I’m still immersed in Minecraft and Rock Band 3, and if I were to add Skate 3 to that list, I probably wouldn’t be able to find time to play another video game for all of 2011…

Some things that I found interesting about Tiny Wings:

• It’s a one-button game, using a mechanism that works well and that I haven’t seen before. Which makes me happy for the medium: if there’s valuable novelty there, there’s valuable novelty everywhere.
• It has a procedurally generated world, but each world persists for a day. (Rather than giving you a new world every time you play or having the world persist indefinitely.) I’ve never seen that before, but it works well in this context. Incidentally, Jason Rohrer has some interesting things to say about different possible benefits of procedurally generation worlds on the latest Experience Points podcast, starting around 25 minutes in.
• The game’s achievements do a better job of serving a mentoring function than those in any other game that I’ve seen.

Actually, I think I have a fair amount to say about that last topic, so let me break out of bullet points for a bit:

At any given point in the game, there are at most three achievements available to earn. You start off with an initial nest, and with three tasks to accomplish: once you’ve accomplished all three, you get a new nest and a new set of tasks, and repeat. Which is already pretty foreign to the traditional notion of achievements; in fact, the game uses the term ‘objectives’ instead of ‘achievements’, so I guess I’ll go with that.

Some of the objectives are strictly about showing off your mad skillz: reach the Nth island. And some of them are gimmicky: the one that sticks out the most to me in that regard is the one where you have to turn your phone upside down and reach the 5th island.

But most of them don’t fall into either of those categories. Or at least they didn’t to me. To me, the metric that “really” mattered was: how far did I get? (For the record: I’m no stranger to the 7th island, though I don’t reach it most of the time; I’ve reached the 8th island exactly once.) But there are a ton of other metrics that the game provides, should you chose to pay attention to them: score is the most prominent, but there’s also the number of coins, the number of cloud touches, time spent in fever mode, the number of great slides, and probably others.

Most of the objectives center around one or another of these metrics: collect 200 points, do 5 great slides on the third island, etc. And the truth is: without the nudge given by the objectives, I wouldn’t have spent as much time on those metrics: I wouldn’t have spent several hours over the course of a couple of days trying to stay in fever mode for 34 seconds, for example. (And, in retrospect, I’m still kind of amazed that I succeeded at that one…)

But another truth is: I’m glad I followed that nudge and did so. It added texture to my experience: without these varying goals, I would have just been touching the screen over and over trying to get as far as possible, and I would have gotten bored and frustrated fairly soon. But with the different goals given by the objectives, I had to think differently about my approach to the game: how would I play it if I really want to get a lot of cloud touches? What causes me to drop out of fever mode? The difficulty curve set by the objectives was also very well done, which was a big help in keeping me interested.

And, it turns out, pursuing those alternate goals helped me make progress towards my main goal of going as far as possible. Take fever mode as an example: if you want to make it to the later islands, you can’t come to a crashing stop very often, at least once you’re past the first three or so islands. So staying in fever mode is very useful; and barely missing great jumps, while not as useful, is generally better than completely botching a jump.

In fact, to my surprise, I actually learned quite a bit about how to play the game from some of the objectives that seemed like gimmicks at first blush. For example, one (late) objective asks you to do a great slide directly after an island jump five times in a single game. That is hard to do; until then, I was happy when I got great slides in those situations but also kind of surprised. But that objective made me think about exactly what I needed to do to maximize the chance of that happening (generally, you want to go for the second depression, and start diving quite a bit earlier than normal), with the result that I could make it farther even when I wasn’t trying for that objective.

Or, a more dramatic example of this: another objective asks you to reach the fourth island without doing a single great slide. Which was difficult both because it’s hard to avoid doing great slides and because it’s hard to make enough progress while doing that to make it to the fourth island. I eventually figured out a technique for the latter (ask me in the comments if you’re curious), but the former was more interesting to me. In particular, once or twice I got frustrated because the game credited me with a great slide when I hadn’t touched the screen at all: I hadn’t slid, let alone done a great job of sliding! But once I’d gotten over that frustration, I realized that I’d learned something potentially useful about the range of possible approaches to great slides: and while I never tried consciously to earn great slides without touching the screen at all, I did switch my approach towards earning great slides. Before, I’d always held onto the screen until I’d hit the ground and started, well, sliding; these days, though, I only hold onto the screen until it becomes clear that I will earn a great slide, and then I release the screen even if my bird hasn’t hit the ground. And I’m sure it would have taken me longer to realize the benefits of that approach if I hadn’t had that objective.

The objectives also work well in tandem with the daily procedurally generated islands. It turns out that some sets of islands are better suited towards some objectives than others: for example, the first time I saw the objective that asked me to reach the fifth island without any speed coins, I had islands with several pairs of adjacent speed coins (and, I believe, one trio of adjacent speed coins), making that exceedingly difficult. So I was glad that, the next day, I’d have a fresh set of islands to play with. But the flip side is: frequently I’d get a set of islands that seemed reasonably well suited to my objectives, but where I’d want to practice on those islands to improve my skills to meet them. (For example, the islands might have approachable enough beginnings to make great slides after island jumps plausible, but even so, I’d need to practice on them a lot before I could hit those great slides at all reliably.) So I very much appreciated the stability of having a set of islands last for a day, while also enjoying the novelty of having a different set of islands each day.

So: yay achievements! And there’s a lot here that other games can learn from. For what it’s worth, the objective that did me in was reaching 175,000 points: I only came close to that once (my top score is 163,707 points, but it’s 20,000 more than my second best score, and my 8th score is under 130,000 points), but I enjoyed my attempts at reaching that bar.

(By the way, I’m ‘davidcarlton’ on Game Center, if anybody wants to add me.)

A correction in regards to my earlier post on “employees as commodities”. My guess as to why my peer bonus gift cards was cancelled was incorrect: a former coworker got curious and asked around, and it turns out that, due to a mishap, a bunch of gift cards got cancelled. And Playdom decided not to tell any of the recipients. So it wasn’t directed at ex-employees: current employees also had their gift cards cancelled, and also didn’t find out until they tried to use them (or check on the balance).

Which is odd in its own way, but I’m glad to learn that this isn’t directed at ex-employees, at least. And if any of my former coworkers are reading this, and you got a peer bonus in January that you haven’t used, you might want to check on the balance of the gift card first…

I played through Planetfall recently (still an amazing game, about which more later); but, before doing so, I had to decide what platform to play it on, given the plethora of Z-Machine interpreters. And I decided to give Frotz on the iPad a try.

That was an experiment, but not a particularly eccentric one: I far prefer reading PDFs on the iPad to reading them on a computer screen, and it’s better for reading e-mail, blog posts, etc. as well. In general, if you want to read text, the iPad (in vertical orientation) is the way to go: it does a great job of being a programmable sheet of paper. So, given that, interactive fiction seemed like a pretty good match. (And in a horizontal orientation, it’s a natural match for point-and-click adventures; I certainly thought it was a good fit for Puzzle Agent.)

The verdict: it worked well, but not as stunningly so as I’d hoped. For one thing, a text adventure (at least in its Infocom iterations) isn’t something that you play just with a device: you play with pen and paper at hand, to make a map and take notes. So I couldn’t just curl up on a sofa with the iPad: I had to be sitting somewhere where I could write and draw. Now, that’s not necessarily a drawback for playing on the iPad as compared to a computer: I’d have the same problem if I were trying to curl up with a laptop! But it does mute one of the iPad’s main advantages.

Also, the interface isn’t a joy to look at and use the way, say, Reeder is. The margins are nonexistent, the font is too small, there aren’t the sort of surprising touches that the best iPad apps have. Again, this doesn’t make it any worse than a computer Z-machine interpreter would be, but it missed a chance to be better.

And, finally, there’s input. The iPad is great for reading and for touch interfaces; it’s acceptable but slightly annoying to use for typing. Which you do a lot of while playing a text adventure! Also, not infrequently you’d like to use the up arrow key to edit your previous input, but that’s not available on the iPad. So that’s a bit of a bummer, the one area where a computer has a clear advantage.

Those are the downsides; the truth is, though, that most of them aren’t downsides as much as a lack of a potential upside, and it remains a nicer device to get close to than a computer. Still, there’s a lot of room for improvement! At a minimum, I’d prefer better layout and typography; and if somebody could come up with a keyboard interface that was a little less grating (maybe providing an up-arrow somehow, maybe somehow working each game’s dictionary into the autocompletion?), that would be great. And if there were a good way to draw maps in-game, that would be awesome: I see that Frotz does have a note screen (though I only discovered it after finishing Planetfall), but most of the time what I really want to do is draw maps instead of typing textual notes.

My guess is that I still prefer text adventuring on the iPad to text adventuring on a computer. But it’s closer than I expected; I should probably do my next experiment on a computer instead. Fortunately, I was impressed enough by how well Planetfall has held up that I’ll probably do so sooner rather than later!

I’ve been at Sumo Logic for about a month and a half now, and I’m really enjoying myself: very interesting programming, great coworkers, and I’m quite optimistic about our product. So if you live in the Bay Area and think it would be fun to write Scala code to do real-time analytics on very large data sets, we’re hiring, please join us! Or, if Scala isn’t your thing, we also have a product manager opening, a dev ops opening, test automation openings, and a user experience opening.

When I first started playing Minecraft, I spent most of my time, well, mining. Or at least underground: I’d obsessively dig stairs going straight through the rock in one direction or another, I’d occasionally hollow out a blocky room whenever I needed a space for a chest or a crafting table, and every once in a while, I’d run into a natural cave, some of which were mundane and others of which were spectacular.

Eventually, though, I got bored (or perhaps overwhelmed) with those underground caves, so I decided to work on a house. I didn’t head outside to do that, however: the opening of my mine was at the base of a fairly large hill, so I decided to hollow out the space above the entrance into a room.

Since I was working above ground, I hit the side of the hill fairly soon, so I put in a window. And, as I continued to enlarge that room, I hit another side of the hill; following my Christopher Alexander fetish, I recognized this as Light on Two Sides of Every Room.

One of Christopher’s Alexander’s main points is that you shouldn’t design buildings in isolation, you shouldn’t design them abstractly: you should design them in context, you should design each building so that the area around it is made richer by the presence of that building. And one of the wonderful aspects of Minecraft is that it’s a building game that encourages such an approach. Yes, if you want, you can build in Minecraft as if you were working with Legos, assembling the blocks that you have at hand into whatever shapes you find pleasing. But one of the most amazing aspects of the game is the terrain that it generates: and a building that fits into that terrain and finds a way to fill a gap that is missing is much more powerful than a building that’s plunked down into a plain that you’ve artificially leveled.

Indeed, going through Alexander’s fifteen properties, we see many that have echoes in Minecraft. The walls of the house that you build to survive your first night are an excellent example of Boundaries. The wonderful overworld combined with the importance of mining (and with natural caves bringing space to the interior of the earth!) provide Deep Interlock and Ambiguity and Positive Space in a context of Contrast. The large blocks, in their own way, provide Roughness; the terrain is full of Good Shape, and not infrequently I turn a corner and am struck by a wonderful waterfall (or lavafall!), a single tree in just the right place, or a forest of trees filling a valley, any of which makes a Strong Center indeed. And the range from single blocks to trees to hills to mountains to the span from bedrock to the top of the sky has room for several Levels of Scale.

Which isn’t to say that it’s a perfect Alexandrian space. There is room for several levels of scale, but the size of the blocks imposes a limit: the world may stretch on forever horizontally, but you only have 256 blocks of height to play with. And the context that Alexander wants you to place your buildings into isn’t defined only by the pre-existing shapes that are present: it’s the context of the people who will be using those buildings, people who are (pace the pleasures of multiplayer servers) almost entirely absent in Minecraft. Nonetheless, as much as I’ve enjoyed other construction games recently (Social City being the most prominent example), Minecraft does a much better job of providing context.

And it certainly does a good enough job of providing context to make me realize that I’m pretty bad at architecture! Take that picture above: one of the windows in question is at an angle (so it’s perhaps more light on one-and-a-half sides rather than two sides of a room), and the wall between the two is a much weaker center than a corner would be at that location. In retrospect, I was much too deferential to the existing shape of the hill when I hollowed out that room: I should have taken a slightly firmer touch in places, reshaping the walls to make the interior space more usable while not harming its outside appearance. I tried to do that some on the third floor, but that also led to problems: I ended up extending past the sides of the hill in a few areas, with the result that there are overhangs above the windows on the second floor, meaning that they didn’t provide as much light as they should have. And one side of the hill in question led into a natural arch; a wonderfully strong center in its own right, but again windows facing that arch didn’t provide enough light to make the adjacent rooms really livable.

Still, I got better at creating and enhancing centers as I proceeded up the hill. I’m rather fond of the way the third floor balcony turned out: the Deep Interlock and Ambiguity that it provides as a Boundary between the interior and exterior, the Level of Scale that it provides in relation to the larger interior room, and that sunset view is hard to beat. The stairs going up the outside of the hill from that balcony also provide a nice accent to the existing shape of the hill, and, going further up, there’s a turning set of stairs inside a large glass enclosure that provides an even bigger boundary area between inside and outside than the balcony did, while solving a somewhat thorny problem posed by the pre-existing geometry of the hillside and my third floor room. Up on the roof, I originally planted five trees before chopping down all but one of them, since its power as a Strong Center would more than make up for the absence of the other four.

There’s so much more to do, so much more for me to learn. I’ve hollowed out perhaps a quarter of that hill: how best to acknowledge the rest of it? And then, how can I move away from the crutch of using an existing hill to form the shell of my house: how best to build houses outside in the Minecraft landscape, at first hoping only to not mar the beauty of that landscape too much, but eventually finding ways in which I can make the landscape a bit more whole? And how to reconcile that with the part of me that likes digging corridors, that would enjoy nothing more than to lay down minecart tracks in a straight line all the way to the horizon?

Edit: The speculation in the second half of this post is incorrect, see this followup for clarification.

Probably the main reason why I wasn’t unhappy to leave Playdom was that I’d gotten the feeling that much of the upper management viewed the company’s employees as commodities. After the acquisition, the company didn’t make any effort that I saw to keep its employees around; partly as a result, lots of people left, including quite good people, and I didn’t get an impression that upper management saw this as a problem. The company also didn’t pay for anybody to go to GDC this year who wasn’t speaking: fine for me personally even if I’d stayed there, I don’t see any reason why Playdom should have paid for my pass, but I imagine that I would have felt differently if I were a game designer.

To be fair, Playdom didn’t force people to take vacation time to go to GDC, which does cost more than the price of a pass. The startup perks haven’t entirely gone away, either: as far as I’m aware, there are still free lunches and dinners, and they were good enough that I didn’t bring my own food from home. More importantly: there are a lot of people there who care a lot about their fellow employees and about the games they’re making. (Speaking of which, give their latest, Deep Realms, a try! It’s a dungeon crawler with a lot more item / attack management than other Facebook games that I’m aware of.) But I was recently reminded of Playdom’s bean-counting aspects when I went shopping this weekend.

Playdom has an employee bonus program, where each person can give out cash bonuses to a few coworkers each year. Which has its pluses and minuses, but I will say this: I gave out a couple, and they meant something to me on a personal level, and the one I received meant something to me as well. The bonus comes in the form of an AmEx gift card; I’m assuming the thought there is that it’s a tangible object that you can hand over to the person you’re giving the bonus to, to make it more of a personal ceremony.

The down side of a gift card, though, is that it’s a little hard to use up (compared to, say, having extra money magically appear in your paycheck); so mine sat in my wallet for several months. But I had an extra-large grocery bill this weekend, I asked the store if they could split it among multiple payment sources, and tried to use up the gift card that way.

I failed (doubtless annoying the customers waiting behind me in the process; sorry!); when I called American Express, it turns out that Playdom had cancelled the card. So I guess, from Playdom’s point of view, it wasn’t a cash-equivalent bonus after all, or a recognition by a coworker for what I’d done in the past: it was a loss that they were happy to pounce on when they had the chance.

Don’t get me wrong: this was not some sort of huge bonus or anything, nothing that I actively regret losing. (So, actually, I’m more surprised at the pettiness of their canceling the gift card than anything else.) Going through the Kealia acquisition and then the Playdom acquisition, however, has been an informative illustration of some of the different ways that companies (both the small companies being acquired and the large companies doing the acquiring) view their employees, of what matters to people with the real decision-making power within those companies. (I imagine if I’d stuck around through the Oracle acquisition, that also would have provided an interestingly different perspective.) Something to keep in mind if I’m ever in a position to affect such decisions at Sumo Logic, or to try to feel out whenever the next time might be that I’m considering changing jobs. (Which I don’t expect to be any time at all soon!)

I usually listen to podcasts when I walk to and from work or do the grocery shopping, which means that I like to always have a set of earphones in my pocket. And, unfortunately, they have a habit of breaking more often than I’d like: it’s not unusual for me to have to buy a new set every two or three months. Which is annoying!

So, given my lack of luck and finding a pair that will work reliably, I thought I’d ask for help. Recommendations? Some things I’m thinking about:

• All things being equal, I would of course prefer ones that sound better. I realize that you can’t ask for too much out of earphones that live in my pocket, and I mostly listen to non-musical podcasts, so I’m not willing to pay a huge premium for better sound, but I don’t want the sound to be super-crappy, either.
• A built-in microphone for phone usage is nice but not essential: I’d pay somewhat more money for that, but I’m quite willing to consider ones without a mic.
• I’d be happy to spend more money on pairs that I had reason to believe would last longer: I’m more or less trying to minimize the total replacement cost per year of use, subject to the points above. Though the flip side is I’m not quite sure what evidence would convince me that a given pair of earphones would last more than three months or so!

Any suggestions? For what it’s worth, ones I’ve been using are: these V-MODA ones without a mic, these V-MODA ones with a mic, and Apple’s. All of which sounded acceptable, but none of which reliably lasts more than three months.

I (along with a lot of other people) was curious about Diaspora when it was first announced, though I can’t say that I’ve been too excited about its initial release. (Incidentally, feel free to add me if you’re already on Diaspora, and I also have invites available if people want them; I don’t currently plan to check the site at all frequently, however.) It seems to focus more on restricting on whom you publish different updates to than anything else; I don’t want to minimize the importance of that, but I personally am not very worried about restricting my updates, and to the extent that I’m interested in selectively publishing my updates, I’m more interested in having that as an option for readers to chose than one that publishers choose. (I also far far prefer Twitter’s asymmetric following model to the symmetric one that Facebook uses and Diaspora copied.)

To me, the most interesting aspect of the project as initially announced was its decentralized aspect. That seems to have been largely a failure at the start: it was possible to get accounts on different nodes, but the early buzz seemed to be that they didn’t all work equally well, and all the people I’m following (all four of them) are on the same node as myself. I don’t want to second guess Diaspora’s apparent choice to deemphasize the decentralized aspect of the project, but personally I would be more interested in its possibilities if aspects weren’t there but if people were spread across hundreds of nodes, and if it were easy, performant, and secure to run your own server instance. Hopefully that will come, though, and that probably wouldn’t make any difference at all from a social point of view, so I guess I shouldn’t worry too much about that. And I certainly don’t want to write off Diaspora: it seems to still be getting a healthy stream of commits, which is great.

Anyways, enough about Diaspora: what do I want social network publishing to be like? My current model is to do all my posting on Twitter, with that syndicated to Facebook. That has some good aspects: my attention isn’t spread, I feel at home in my Twitter feed but I also appreciate the comment threads that occasionally pop up on Facebook, I have a social graph available for Facebook game purposes. But, of course, it also some bad aspects: it gives too much control to Twitter (I don’t even have an archive of my own posts!), Facebook is more of a second-class citizen than I’d like.

So: what can we do about this? One computer science reflex is to solve problems by adding an extra layer of indirection, and that doesn’t sound like a crazy response to the current power that Twitter has over my publishing. (In fact, I’d vaguely hoped at one point that maybe I’d switch to writing on Diaspora, and syndicating from there to both Twitter and Facebook.) The problem with that approach, though, is that you need to make sure that you don’t lose the current benefits of those sites: Twitter isn’t publishing, it’s a conversation. So you’d want to pull in conversations from Twitter and Facebook as well, presenting you with a merged feed (including detecting duplicates from other people who are also syndicating). (Incidentally, one aspect of 龍が如く for Twitter that I really liked was that, when showing you a tweet that was a reply, it automatically included the replied-to tweet as well: yay for increased visibility into conversations.) And you’d want to combine all of that with a searchable archive: I still find it kind of amazing that there’s no way to search your Twitter feed, to pull up past tweets that you’ve read about a topic. (You could further extend that archive functionality, e.g. saving the target for shortened links.) Eventually, you’d want to support direct syndication between instances of this mythical platform, to avoid the need to go through a third party at all. (And exporting a social graph for non-conversational purposes, e.g. games, is important!)

And then there’s the problem of the platform owners. Twitter has a nice and flexible API, but they’ve recently come down hard against third-party clients, and the dickbar debacle has left me with a bad feeling. I’m embarrassed to say, given my previous employment, that I don’t even know what Facebook’s API is like for reading the feed: I assume it has one, except that, if it does, why isn’t there a better iPhone client out there, a Tweetie analogue? (There probably is, it’s doubtless just my ignorance showing.)

My first reaction is that the best place to start attacking something like this would be with the archive aspects. The fact that I don’t have a record of my own microblogging bothers me (though, honestly, less than I would have expected a few years ago: I’m comfortable with the ephemeral nature of my tweets); and if we could combine that with an archive of conversations, so much the better. That’s a concrete task that would force the implementor to confront with the realities of the data; hopefully, adding publishing on top of that wouldn’t be difficult.

Though the problem with taking that kind of data-centric point of view: where is it stored? I depend on having Twitter access from all sorts of places; would I be comfortable adding a layer of server indirection to have access to that? (And that’s just what would be necessary to make clients possible: actually writing them is a whole other kettle of fish!) If I don’t want to have a persistent server, would I be comfortable having my iPhone as the trusted repository for this data?

Thoughts? I’m not seriously proposing this as a project that I’m going to launch into—I have a job keeping me happily busy, after all! And certainly there are way too many social network ideas floating out there. But there is something wrong with social network publishing as it currently stands; I’d like to better understand how I’d like that world to look.

I try to write here about every full length game that I finish, but for better or for worse I don’t have a formal policy about DLC. I thought I might blog about all of the Mass Effect 2 DLC, but I never got around to doing so; and, indeed, I don’t think my brain does well at composing that sort of survey. Maybe I should have concentrated harder on just one of the pieces of DLC and found something to say?

I got the ultimate edition of Dragon Age: Origins, so I had access to all the DLC for that game. And, for better or for worse, I figured I’d just go along with my inertia and launch into the DLC immediately after finishing the full game. (Except for The Golems of Amgarrak: that one seems to be about something that I’d explicitly chosen not to do in the main game, so it would have felt jarring to do it as DLC.) I wasn’t planning to write about any of it, but after a couple of evenings, it became clear that Dragon Age: Origins – Awakening is as long as many full games that I play, so I figure I should say something about it.

So: it’s more Dragon Age. In a different area of the map, one which is festooned with gear that is designed for characters in the level 20-30 range; quite a coincidence, that! You see some familiar faces, but not many (and in particular not my true love; incidentally, would it have been that much work for them to actually take note of that correctly when doing Awakening‘s final credits?); Anders piqued my interest enough that I’m looking forward to seeing him in Dragon Age 2, I rather liked Sigrun’s personality (though she does an awful job of filling the rogue slot), and I wish I’d spent more time with Justice.

And then there’s the plot. Which I was unimpressed by at the start: the Darkspawn menace is supposed to have been quelled for now, but we can’t cook up another similarly dire threat in short order, so we need an excuse for them to reappear. I know, let’s have them talk this time! And then it took a turn for the odd: the Mother and Children get added as another sort of weird Darkspawn enemy, which seems to be trying to take the game in a sort of horror direction, but not at all effectively. (The game kept on telling me how horrifying the Children are, but it sure didn’t feel that way.) The Broodmother bit in Origins hit similar themes, but in a way that hit me much harder.

So I was quite surprised to discover that, when I reached the last couple of hours of the game, I really rather liked the plot, in fact probably much more than the main threat aspect of the plot in Origins. The original game had an entirely cookie cutter main threat, and was cookie cutter in a way that’s politically problematic. We’re at war with an other, they want to destroy our way of life and slaughter us wholesale, and it’s okay to slaughter them wholesale both to return the favor and because they’re mindless drones acting at the behest of their leader. (And they look really different from us, too, which helps make the killing okay.)

That is a scenario that plays out over and over again in the real world. (It’s playing out now, certainly!) And, in the real world, it’s never that simple, even in the most extreme of cases, even where your enemy is doing genuinely horrific things. Yes, the game is a fantasy, yes I happily do a lot of things in games that are horrible in the real world. But still, it’s a lazy plot, in a game that isn’t so lazy in many other aspects.

And Awakening subverts that directly! It works within the constraint of plot continuity, and doesn’t present the Darkspawn as horribly misunderstood; but it does say that yeah, they probably shouldn’t be mindless brutes, so let’s work with that while leaving a certain amount of uncertainty in the situation. (As befits a nation that’s emerged from a horrible war.) Rather well done, as it turns out.

Which isn’t to say that I love everything about the plot in Awakening. I’m not thrilled with the pairing of the intelligent/wise father figure with the misguided and emotional mother figure; for that matter, I’m not that thrilled with the great leader trope at all! Still, I left the game impressed on balance; and playing it significantly increased the chance that I’ll play Dragon Age 2 sooner rather than later.

Libraries, Interfaces, and Dependencies

The code base for my new job is rather larger than the code base at my last job, which means that I have to start thinking about the build process more than I’ve been in the habit of doing recently. I know how to set up a good build system for C-based languages (hint: gcc -MD is your friend), but I’ve never felt as comfortable with the options for Javaish environments, even for relatively straightforward projects that are just building a single program.

And we’re not building a single program: it’s a distributed system, with a collection of programs using some common libraries and some distinct libraries. Which is quite similar to the situation at Kealia, but the build system feels rather different. Part of that is related to the source code layout (we’re putting each module in its own git repository), but part of that is due to differences in the Java/Scala way of compilation and the C-language way of compilation.

At Kealia, our product code was spread across three directories: interface, which had one subdirectory for each library, containing the public header files for that library; lib, which had one subdirectory for each library, containing the .cpp files and private header files for that library; and prog, which had one subdirectory for each program, containing the code specific to that program that we didn’t feel like pulling out to a library. So the build process was in two phases: it built all the library code in parallel, and then all the program code in parallel. (If I’m remembering it correctly, actually, the build system was happy to start working on program code even if some of the libraries weren’t done building, but at any rate dependency chains at the library/program conceptual level were never more than two deep.)

In Javaish languages, though, that doesn’t work, for the simple reason that the language doesn’t have a notion of a header file: if library A depends on library B, then you have to build library B before library A. Java programmers like to talk about how, in C++, header files mean that you have to write your class interfaces twice; that’s a quite valid complaint, but it bites you in situations like this. Though the situation isn’t quite as simple as that description makes it sound: in a lot of situations, Java interfaces end up acting a lot like C++ header files, giving you some amount of separation of compilation while also requiring you to write some of your class interfaces twice. Certainly proper use of interfaces is important in reducing long dependency chains; I don’t think we’ll be able to get down to two levels of dependencies, but what is the shortest chain that we can reasonably get to?

One answer might be three: break each library up into an interface part and an implementation part, like the include and lib directories from my C++ example. Programs should only depend on libraries and interfaces, and library implementations should only depend on other libraries’ interfaces, never on their implementations. That sounds plausible to me, both in terms of being achievable and in terms of being a good idea, but I’m not sure that it’s enough to get us to three levels of dependencies. The problem is that one library’s interface can reasonably depend on another library’s interface: e.g. if you happen to be writing a video server, you might reasonably have some generic MPEG classes that are referred to in the interfaces of multiple libraries, which means that they themselves have to be in a separate library. So that’s four levels of dependency; I can even imagine that it would be hard to avoid introducing a fifth level, because you might have some fundamental data structures (e.g. some sort of widely used numeric abstraction or custom collection) that shows up in the interface of shared classes that are a bit more domain specific.

So: five levels of dependency. That doesn’t sound like a very good rallying cry, does it? Still, at least it’s a stake in the ground, and having those five layers be well defined (programs, library implementations, library interfaces, shared interfaces, and a handful of core interfaces) is something.

Is even that achievable, though? C++ header files define a few different sorts of concepts. There are abstract interfaces; these are a lot like Java interfaces. There are ADTs; these belong in my interface layer above, but contain actual implementation as well. And there are methods that you call without having an object instance at hand: static methods, but also constructors.

What do you do about this latter class of functions? In C-family languages, the linker happily resolves them for you; what’s the analogue for that in Java? I guess the answer there is: if you have a static method (including class constructors) associated to a class that’s not plausibly an ADT, then you have to make sure that there’s an extra layer of indirection involved to let you do the wiring at the program level instead of at the cross-library level. In other words, you have to get serious about dependency injection: library A shouldn’t depend on the implementation of library B, even to do the basic setup for that library. Instead, library B should abstract all those static methods out into an interface, library A should be written in terms of that interface, and every program that uses library A should pass an implementation of that interface to library A. (It can get that implementation from a static method in library B, but the point here is that it’s the program layer that’s grabbing the static method from library B, not library A’s implementation layer.)

At first blush, I think that should work. Actually, it even seems plausible to me that it would lead to better structured programs than you would get if you didn’t worry about rigorously adhering to such standards. Five layers of dependencies: it’s good for your software! (Not the best rallying cry I’ve ever heard…)

Maven

The other aspect of our setup at work that’s new to me is Maven. I’m really not sure what I think about Maven yet: I’m willing to believe it’s better than Ant, but I’m also willing to believe that that is not much of an accomplishment. I like its emphasis on convention, I like the way it’s good at pulling in known versions of external resources (your Scala compiler, your jUnit version, etc.). But I’m less sold on its insistence in separating every artifact into a separate project: what happened to Recursive Make Considered Harmful? And it boggles my mind that, in this day and age, a build system would be written that only supports parallel builds as an experimental feature in its as-yet-unreleased third major revision number bump! We’ve known for most of a decade now that many cores are the way forward, yet I’m using a build system that can’t even keep two cores on my machine busy? That is ridiculous.

Another part of the picture is Hudson: our build system at work is set up so that you’re encouraged to have Hudson build artifacts that you’re not actively touching. (And Hudson is capable of doing those builds in parallel. This perhaps makes it possible to live with the aforementioned Maven limitation, but in no sense excuses it: if I’m starting up a project, I absolutely should not be required to set up a continuous integration server just to get non-braindead compilation performance. I realize that the Java world is not known for its fondness for lightweight systems, but that is… Sigh. I will stop ranting now.) I haven’t yet figured out what the Maven way is here: is Maven perfectly happy for you to have all your build artifacts under your own control, is Maven actively hostile to you having all your build artifacts under your own control, or is Maven agnostic about that question?

This all also bears on the question of source code repositories that I mentioned above. At first, once I got over my surprise, I kind of liked the idea of having each module in its own git repository: let’s take the idea of separate modules seriously. But once we start breaking up one conceptual module into an interface part and a library part, I’m less happy about having them in separate repositories: you’ll want to change an interface and the code that implements that interface in lockstep, which means that changes to them should be part of a single commit. And I’m also not sold on this idea that we should have Hudson in charge of building all these different artifacts for us: maybe I’m conservative, but I still like the idea of checking out a known version of the entire project’s source code, doing a build of it, and getting a reliable, reproducible result.

Lots of interesting questions to think about, lots that I still have to learn. (And that’s without going into my discomfort about dependency info generation for Javaish languages!) Probably the best thing for me to do would be to start a project at home: I should come up with something to write (probably purely in Scala, I don’t think that mixing Java in will either make me happier or clarify the situation) that I can plausibly break out into multiple libraries, so I can really grapple with these dependency issues.

Over the last couple of months, I’ve been going through all the Rock Band 3 Pro Keys songs on Expert, going through each one several times to try to do as good a job on each one as I can. You can find more details on my other blog, if you want blow-by-blow narration, but I figured I’d give a bit of a recap here now that I’m done.

It’s been a very interesting experience. Some of that is what I talked about yesterday: I just don’t put in that sort of repeated focused practice in other video games, and I don’t think other games support that nearly as well as the Rock Band series does, Rock Band 3 in particular. And after years of doing not particularly well in competitive multiplayer video games with the VGHVI crowd (who, I assure you, are an extremely congenial bunch, I can’t imagine losing to nicer people!), I take a certain pleasure in having one mode in a game that I can point at and say that yes, I’m better at this than the vast majority of you. (As of this writing, I’m in 34th place on the overall Pro Keys leaderboard. Though I’m pretty sure that at least one person reading this blog is better at Pro Keys than I am…)

And watching the leaderboards has given me a glimpse into how this game appears different to people with different musical backgrounds: while my ranks on individual songs are all quite decent, they aren’t uniformly so. On some songs, I worked hard and still ended up with a rank in the two-hundreds, while there were other songs where I finished my first run through the song, felt that I’d done a kind of sloppy job, and was already up in the mid thirties. The pattern there seems to be what kind of playing the song requires: I don’t do so well on songs that require you to play the same notes over and over again quickly and precisely, while I can easily imagine somebody who is much better on Expert (non-pro) Guitar than I am will find that those skills transfer over to let them do well on such songs on Pro Keys. Whereas songs that require you to play through melodies and natural sequences of chord changes are ones that I can pull off without much thought at all: my hands know how to do that sort of stuff, no problem. (I knew that figured bass training would pay off eventually!)

When I first started Pro Keys, I found the notation a little bit frustrating, but I got the hang of it soon enough. And one of the realizations I had over the course of that process was that, if an interval was too wide for me to be able to read it at a glance, it was almost certainly an octave: that made certain songs a lot easier for me to play. But, dense as I am, it took me a while to realize the following: that’s very useful for me, because my hand has decades of experience in exactly how wide an octave is, but it’s a lot less useful to somebody who is coming at the game without a keyboard background! And octaves are only scratching the surface: my hand also knows what all sorts of triads feel like, including their various inversions and the combinations of black and white notes that show up in different keys. I have a huge amount of respect for anybody who has made it through the expert songs without a piano background: you (and your hands!) have learned a lot in that process. (My hands have learned something in the process, too: I would seem to be better at playing fast arpeggios with a reasonably even rhythm than I was before I survived Antibodies and Roundabout.)

So now I’m definitely a supporter of the notation that the game uses for notes. It’s obvious what the notation means, and the color divisions make sense on both a musical and a tactile level. It’s still not nearly as second nature to me as standard musical notation is (in particular, I seem to do most of my positioning by comparing the relative location of new notes to earlier notes, combined with knowledge of what makes sense musically, instead of directly translating a note on screen to an absolute position on the keyboard), but I can’t remember the last time when I had to look down at the keyboard when playing, so the notation is more than good enough.

Or at least it’s more than good enough within the constraints of the game. A two octave keyboard is a huge improvement over five buttons, but it’s too small to play all but the simplest of real songs; what’s worse, you’re never playing more than an octave at any given moment. So you play through the whole game with one hand, and while I suppose it’s convenient to have a hand free to activate overdrive, it’s very stripped down compared to real piano playing. (And, I suspect, compared to real keyboard playing in a rock band, though I don’t have any experience with that.) My guess is that the distance between Pro Keys and playing on a real instrument is significantly larger than on Pro Guitar or (probably) Pro Drums, though I could be wrong about that as well. I would love it if Rock Band 4 could have a much more serious Pro Keys mode, though it’s not at all obvious to me how to do that while working within the confines of the screen and without falling back to standard musical notation; then again, if anybody can come up with a way to cross that gap, it’s Harmonix. And, of course, I’d be perfectly happy with a mode that gave standard musical notation while letting me use both hands, though that would shrink the potential audience even more: as is, I’m somewhat worried that Harmonix is on the wrong side of an Innovator’s Dilemma slope.

But if they’re on the wrong side of that slope, it’s because they’re adapting their game more and more to players like me. Good times.

Pro guitar mode in Rock Band 3 turns out to be totally fascinating: I’m still going through the songs on Easy, and I’m amazed at how much there is to learn and think about even on that setting. In particular, last weekend I decided that I would stop looking at my left hand while playing songs, focusing instead on the feedback that the screen and the feel of the instruments provide, and it turned into a much richer experience: I had to learn the locations of the seventh and twelfth frets, the distance between the two of them, I had to think harder about which fingers of my left hand to use when, and the patterns in the notes (reflecting underlying patterns in the music) became a lot more important. And, best of all, I didn’t have to be perfect at any of this: it turns out that the onscreen guide gives enough feedback to let you adjust fairly well in real time (at least if you’re playing with as few notes as Easy throws at you), much more so than Pro Keys does.

I was going to write a long blog post about how special this sort of focused practice in games is, but then I realized that I’d already done so. But since blog posts have a way of being forgotten quickly (even by their authors, it would seem!), I’ll just repeat the ideas here. The game is providing me with a short but meaningful challenge: meaningful in the sense that I have to work a bit to succeed at the challenge, and also meaningful in the sense that, by succeeding at the challenge, I’ll also gain something else that matters to me. (Listening to music, and learning something about the music while doing so.) The challenge is surprisingly rich, containing quite a bit more “depth on demand” (as Randy Smith puts it) than is apparent on the surface: I can decide whether or not I want to look at my hands, I can decide how much I want to think about where my hands should go, I can decide how much to think about the underlying musical issues that inform the challenge, I can decide whether my goal is to finish the song with no fail on, to finish it with no fail off, to finish it with five stars, to full combo it, to do better than my friends who are also playing the game (answer: no, given that Dan Bruno is on my Xbox Live friends list!). The challenge spans a single song, so is over in less than five minutes and can be repeated several times without trying my patience should I so choose; but that challenge is one of seventy-odd songs in the game in a carefully graded progression difficulty, and I have three more tiers of increasing difficulty coming from increasing inherent richness waiting for me once I’m done with those songs.

That is wonderful.

And also rarer than it should be. Some of which is my fault: if I spent more time playing multiplayer FPSes or fighting games, I would see more such focused challenges. They wouldn’t be crafted nearly as well towards my practice, towards improving my craft as Rock Band manages; but those genres also allow improvisation and creation far beyond Rock Band, which is a huge strength. (Hmm, maybe I should spend more time placing racing games: mastering a track provides a focused challenge, while the other racers provide unexpected stimuli to react to.) But I’d love to see a competitive game that comes with a series of prescriptive katas to help hone your skills for use in subsequent improvisation. (Or at least I think I’d love it: I’m not sure I’ve jumped at the learning modes (“virtual reality missions” and the like) in games that have tried to provide them. I did like the graded bot challenges in Perfect Dark, though…)

But it’s not all my fault. Too many games throw repetition at you for the sake of repetition, typically using the promise of narrative advancement as a lure to get you to put up with the repetition of the challenges. (And, sadly, the narrative is as threadbare as the challenge, more often as not: super wonder meh twins unite!) Admittedly, I could change my approach towards such games—when confronted with narrative games, I tend to dial down the difficulty level rather than embrace the challenges at the expense of prolonging my progress through the narrative—but there’s no need for games to force me to make that tradeoff, or to present me with two unsatisfactory choices rather than two tantalizing choices.

And I do need to improve my skills for thinking and talking about challenges in games. One of my favorite parts of working at Playdom was having excuse to play board games every week (with really fascinating company): those games focus much more on their mechanics, they’re fascinating, but I haven’t talked about them here as well. One of my favorite games over the last year was Flight Control HD, and right now I’m going through Tiny Wings: again, both focus on the mechanics, and Tiny Wings also does a rather good job of giving you focused challenges to help you see more of the ramifications of those mechanics. If that’s what we’ll find in this new world of cheap iOS games, then there’s a lot of good to be found there.

But also a lot of good to be found beyond there. Just put together the focused learning of Rock Band 3‘s pro modes with the improvisational possibilities of our best competitive games, and find a way somehow to couple that with narrative that reinforces and is reinforced by the mechanics. And do it all while mercilessly removing padding. That’s not too much to ask for, is it?

Applying Compose Method

After I wrote that post on precedence, map, and function composition in Scala, I started to wonder: I’ve been thinking that I should experiment more with applying Compose Method. That refactoring recommends that, if I start with the original version of my code,

data.foreach(s => writer.addDocument(createDocument s))

then I should extract the body to a method. Which, I guess, would lead me to something like this?

data.foreach(addStringAsDocument(_, writer))

Except that that’s actually not what Compose Method really recommends: that’s merely one standard way of applying it to languages that are somewhat lacking in expressive possibilities. If all you have are manual looping constructs, and if you want to “keep all of the operations in a method at the same level of abstraction” (Smalltalk Best Practice Patterns, p. 22), then yeah, you’ll pull out your loop bodies to methods, but there are other ways to reach that end.

So, looking at the code that I actually ended up with that post (with the kind help of my readers),

data.map(createDocument).foreach(writer.addDocument)

is everything there at the same level of abstraction? That’s not entirely clear to me: if I wanted to, I could certainly extract a couple of methods out of that, and end up with something like this:

addDocumentsToWriter(createDocuments(data), writer)

Examining Alternatives

We’ve seen four examples of how that code could look; let’s replace the first of those with one that raichoo suggested on the previous post, giving us the following list:

1. data.foreach(createDocument _ andThen writer.addDocument)
2. data.foreach(addStringAsDocument(_, writer))
3. data.map(createDocument).foreach(writer.addDocument)
4. addDocumentsToWriter(createDocuments(data), writer)

Anybody want to argue for any of these being noticeably better or worse than all of the others? I’ll have to say: while they all seem fine to me, I can’t get too worked up over the need for using Compose Method in this case. Though, as I’ve been typing them up, I’ve wanted to add “fromString” in various places, which suggests that the method name createDocument is perhaps not as well chosen as it could be: maybe I should have called it something like stringToDocument instead?

Hard to say, I’m still happy enough with the third option. It says fairly directly that I’m starting with a bunch of data, turning it into a bunch of documents, and adding them to the writer: fine by me. (The first option seems approximately similarly expressive to me, as well.) There are, of course, situations where one or the other composed method would be preferable (as I said at the end of that earlier post, I ran into one an hour after I ran into the above!), but this doesn’t seem like one.

Recomposing and Natural Transformations

Maybe it’s the category theorist in me, but this also raises one other question: consider the two composed methods, 2 and 4 in the above list. Say that you reflexively went with option 2, but then decided that it didn’t seem quite right. You could (probably would) inline the function, and then distribute and regroup to end up with the fourth version; that seems like a pretty standard sort of thing to want to do. (It wouldn’t be too much of an abuse of language to call it a natural transformation!)

So: if we’re going to make a taxonomy of micro refactorings, might we not only also want to list ways of composing them (as, indeed, Refactoring itself suggests; see also Refactoring to Patterns or the hierarchies of patterns in A Pattern Language), but also ways of undoing them and composing them differently, along the lines of associativity laws?

I recently played through Loom along with the Vintage Game Club, and I wished I had more to say about it. It’s a point-and-click adventure game; instead of accumulating an inventory of items to use, however, you accumulate an inventory of tunes. Which is a pleasant change of pace, and helped make the puzzle solutions be less arbitrary: there’s not as much “find the key to use here”, or “find the completely arbitrary object to use here” as in other adventure games, instead each tune has a function, you can generally figure out which tune to invoke to do what you want in a given situation, and there are tunes that are used in multiple situations and even puzzles that allow multiple solutions.

Having said that, it’s still an adventure game. So yes, you will get stuck at times; sometimes you’ll feel like it’s your fault, but not infrequently the environments were hard to navigate, and there were some crucial item interactions that I missed where the game could have helped me more. It has more of a plot than a lot of early adventure games (though, to be honest, I’m actually not that familiar with graphical adventure games), but the plot ended up disappointing me more and more as the game progressed, and KAOS Chaos was just ridiculous.

It’s a short game; these days, that’s normally a good sign for me, except that it didn’t feel like the sort of short game where every part had its place and there was nothing more to add without being superfluous. Instead, it felt like it was a bit rushed, like they didn’t have time to polish it. So, while its length wasn’t an active negative (I’d rather have an unpolished short game than an unpolished long one!), it also wasn’t an active positive.

A pleasant enough way to have spent a few hours and a few dollars; I’d just hoped for more.

Now that my Squier and MIDI adapter have arrived, I’m starting on the Pro Guitar mode for Rock Band 3. I’m mostly going to be blogging about it on my gaming experiences blog, but I figure I should mention it here in case somebody was curious to read about it but was put off from that blog by the mass of Minecraft and Pro Keys posts. I imagine that I’ll post about the experience here sporadically as well: that blog is for diary-like stuff, while this blog is more for talking about what I’ve learned from the experience. (Then again, it’s not like I’ve been posting here about what I’ve learned from Minecraft and Pro Keys, despite my intention to do so! One of these weeks…)

All the Pro Guitar posts should be under the tag “pro guitar“—WordPress even automatically generates an RSS feed for the tag should you be interested.

Another podcast that I got around to listening to in my GDC commute was the CDC Podcast episode on “A Post-Comment World”. And thinking about that episode added a twist to my understanding of forms of publication and discussion on the web. The number of online publication niches continues to grow: it’s not just blogs and Twitter, there’s Facebook (including posts, comments, and likes), Tumblr, Quora, Buzz, Formspring, and I’m sure that all of my readers can add another half-dozen types onto that list. And I continue to be amazed at how each of those niches functions differently: you’d think they’d be redundant, but they each have their own reason to be.

So: say somebody has written a blog post, and you want to respond. Where might you do this? On the comment thread to that blog post, of course. Or you could be motivated to write a blog post in response. Or you could post about it on Facebook, or comment or like somebody else’s post on Facebook, or simultaneously post it on Buzz and share it in your Reader shared items, or you could link to it on Tumblr, or you could tweet about it. (Or you could talk to people in person about it, or talk about it on a podcast, or e-mail the author, or write a book about it, or write an academic journal article about it! But I digress.)

These all have their roles, these all have their distinct characters. A Facebook like is the simplest signal, while a blog post response is probably going to allow for the most thought and nuance. Facebook comments are short-form and part of a conversation among a few people; Buzz comments have that same conversational feel but, in my experience, have room for more context; Twitter is similarly short form but less conversational and is read by a broader audience.

As a blog author, you may prefer some sorts of response to others. And, to some extent, this is in your control. If you want responses on Facebook or Buzz, you’ll forward your posts there; if you don’t, you won’t. (Not that you can prevent other people from linking to your posts in those fora, of course.) If you want responses on your own blog, you’ll have it open for comments; if you don’t, you won’t.

It strikes me as entirely reasonable to value and hence want to actively encourage some of these forms of discussions more than others. Roger Travis, for example, has decided that he finds Buzz discussions more useful than comments on his blog posts, so he’s turned off comments on his blog posts and encouraged people to comment on Buzz.

And I suspect that many blog authors would prefer responses to their posts that come in the form of other blog posts. We’re likely to learn more from such responses, because they’re likely to be longer and less impromptu; and we also like the ego boost that comes from somebody’s being inspired enough by what we have to say to take the time to write a post in response. If that’s where you want responses to appear, then turning off comments is a pretty reasonable strategy.

I would also say that it’s an overly optimistic strategy—what are the chances that somebody would write a blog post instead of leaving a comment?—except that I’ve done that twice myself in response to Ben! In both instances, I probably would have left comments on his blog instead of posting on my own blog if that option had been available to me; I suspect that Ben is glad that I responded on my blog in both cases, and I know that I’m glad that I responded on my blog instead of in comments, because I learned more from the act of writing the blog posts than I would have from leaving comments.

Listening to the podcast discussion made me wish that more people turned off comments on their blogs, not because I think it’s a superior strategy but because I’m curious how that would affect the culture of response. And, now that I think about it, on the culture of craftsmanship that goes into writing blog posts: by stepping away from the possibility of immediate conversation, would authors feel compelled to put more work into ensuring that posts stand as objects on their own? (Ben, Daring Fireball, and Kill Screen all care about aesthetics, certainly.) I’m not yet convinced that I should turn off comments myself, though perhaps I should fork off another comment-free writing space where I take more care with what I produce; in a gesture of solidarity with Ben, though, I will turn off comments on this particular post. (While leaving on trackbacks: I’m all for blog-to-blog conversations!)

One of the side effects of attending GDC last week was that I spent a lot of time in my car; not my favorite place, but at least I got to catch up with podcasts. In particular, I’m glad that I had time to listen to the three part Critical Distance “2010 in Review” podcast: it’s about three hours long, but there were great guests on it, and I always like listening to smart people talking about games. They started off by talking about events of the year, blog posts and articles that seemed particularly interesting; then they switched to going through an incredibly long list (I didn’t count, but my guess would be about 50 games; kudos to Eric Swain for assembling it) of major 2010 titles, and talking about whichever ones they had something to say about. (Which turned out to be most of them: the participants were an opinionated, talkative, well-informed crowd!)

Quite a show. But then, when it ended, I realized: I have three personal candidates for 2010 game of the year, and yet none of them made it on that list despite its length! What’s going on with that?

One of my candidates is Minecraft, and there I think the answer is clear: the game doesn’t have a release date. I can’t remember for sure, but it wouldn’t surprise me at all if they actually did talk about Minecraft in the first half of the podcast; it’s just not going to naturally show up in a chronological list, though, and you could make a case that it’s not a 2010 game at all.

Another one of my candidates is Rock Band 3. I’ll have to chalk that one up to an oversight (I know one of the podcast participants is a big Rock Band fan, though I don’t think he had input into the creation of the list): it’s a huge advance in an important gaming franchise, of course it should be on there. But your eyes glaze over when going through comprehensive lists of releases, it’s impossible not to occasionally miss something when whittling them down to a manageable size.

My final candidate is Flight Control HD. It makes my list by virtue of being an incredibly fun game, superbly matched to its system, that I cannot imagine improving: it seems to me to be a local maximum in the design space of games in the same way that Tetris is. But it wasn’t on the list. In fact, no iOS games were. (I’m not a huge Angry Birds HD fan, but a lot of other people are, and Osmos has certainly gotten its share of buzz.) Actually, did I miss an Angry Birds mention in the podcast? Christopher Williams mentions it in the comment thread, so maybe it did show up in the podcast list? Unfortunately, it’s hard to check facts about a three-hour long podcast…

And the iPad and iPhone aren’t the only platforms that were left out. I honestly can’t remember if any DS games were listed, though I suspect not: I just checked July, and Dragon Quest IX is missing, which is the first candidate off the top of my head. (I also can’t remember if any PSP games were listed, but I have no idea what games came out for that platform in 2010.) And the other missing platform is Facebook: I bet CityVille has been (is still being!) played by more people than any other game in their list, but it’s missing, as are FrontierVille, City of Wonder, Ravenwood Fair, and Cow Clicker.

Lists like the one on the podcast are always going to be incomplete; having said that, this complete omission of games on three of the current most popular platforms seems like a pretty big oversight to me. So I’ll repeat my question from above: what’s going on with that?

Eric is the only person who can answer; maybe he’ll chime in in the comments. And I don’t want to turn this into some sort of big accusation or anything: I really enjoyed the podcast, and it’s a lot of work making a list like that, so I don’t want to turn that into something that’s even more thankless than it would otherwise be. But in the meantime, I’ll speculate.

Presumably he’s not a fan of games on those platforms. That is, of course, perfectly fine: there’s no reason why he, or anybody else, should be! And one’s tastes are always going to affect the contents of lists like this that one creates.

Another contributing factor is probably the fact that it’s a Critical Distance podcast. And there just aren’t that many blog posts about games on those platforms on the sorts of blogs that Critical Distance links to. (I’ve been sadly remiss in discussing such games myself.) Or at least about any of the games I mentioned above other than Cow Clicker, but that game is enough of a special case that I can see its not being included.

And another potential contributing factor is that games on those platforms aren’t targeted at people like those who participated in the podcast. At GDC, the phrase ‘forty-three year old woman’ was bandied about a lot; as far as I know, all the podcast participants are men in their twenties. As are a lot of the authors of blog posts that Critical Distance links to, so this factor and the previous one are linked.

Christopher Hyde has been pointing out for years how much tunnel vision the “critical game blogging” community has: we (and I very much include myself in this) spend an awful lot of time playing and talking about AAA games, which seems to more or less mean games targeted at men in their twenties that are expensive to make and sell lots of copies. There is, of course, nothing wrong with talking about such games; but there are a lot of other spaces worth exploring.