malvasia bianca

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.

In a role-playing game, you customize your character’s abilities, refining that customization as the game progresses. Your character will typically have a class (fighter, mage, priest, rogue, etc.), which you pick at the start of the game and generally doesn’t change; this sets broad limits of your character’s abilities. You also typically have cross-class attributes (strength, dexterity, intelligence, wisdom, charisma, constitution, etc.); these increase as you level up, letting you focus on areas that are more important to you. As you level up, new class-specific abilities also appear: for example, a mage may learn new spells as she levels up. Sometimes these new abilities are determined for you; sometimes you have a range of potential abilities to learn that you can choose from. And sometimes there’s further branching: for example, in the most recent role-playing game I played, Dragon Age, each class has four specializations (of which you can eventually choose two), and each time you level up you’re able to pick one of a dozen or so abilities to learn, some of which are tied to a specialization, some of which are tied to your class, and some of which are available across classes. And that’s not all: some games allow you to change classes if you level up far enough, and some dispense with the concept of class entirely, allowing you to mold your character as you choose based on the attributes and abilities that you select.

In general, I’m drawn to these more flexible games: I like the idea of shaping a character according to my playing style, according to the way I like to behave, even according to my idea of the sort of person that I am. Even in these more flexible games, though, classes are latent: not all combinations of choices are equally powerful, so if you search forums or wikis or gamefaqs, you’ll find recommended builds, giving you combinations of attributes that work best to, for example, allow you to do the most damage in the game, or absorb the most attacks, or heal your party members the most. (The presence of multiple members of your party encourages this sort of specialization.) You can ignore these, but you do so at your peril: you’ll have a hard time making it through the game on hard difficulty settings if you’re haphazard about the choices you make.

This focus on character construction is one of the ways in which role-playing games are adolescent games: they’re all about figuring out whom you want to be when you grow up. Which, like all great themes, actually spans all ages. Or maybe I’m stuck in adolescence, because I’m still trying to figure whom I want to be when I grow up!

And, just as I prefer more flexible approaches to building your character in role-playing games, so too do I prefer that when constructing my life. I’ve already changed classes once: while I don’t talk about it much here, I leveled up for years as a mathematician, eventually spending five years as a postdoc at Stanford. At which point I changed classes, becoming a programmer. (Fortunately, I’d leveled up that skill while growing up and during my undergraduate years.) One debate that I’ve had over the last few half-decade was whether I wanted to change classes again, and become a manager; I dabbled with that for a few years, though these days my general feeling is that I’m a better fit as a programmer. (Actually, my real feeling is that I’m a better fit as a member of an anarchist collective, where either nobody or everybody is a manager, but never mind that.)

But, of course, not all programmers are alike: and life is definitely the sort of game where you have to choose where to improve your abilities, you don’t have preset skills that you gain as you advance. (Outside of college curricula, at least! Which is one of the reasons why I don’t like them, I suppose.) I have a habit of going deep enough into some area to be able to do pretty well at it, and then switching over to something else rather than going all-in. (The exception, I guess, is agile: it’s both deep and broad enough that I haven’t yet gone all-in with agile, but I also haven’t stopped exploring further.) I switch domain areas fairly frequently: programmer tools, then streaming video, then video games, and now computer security. And, as a bonus, I don’t even go all-in on programming as a whole: yes, there are 208 posts on this blog tagged with ‘programming’, but there are 327 tagged with ‘video games’. (Similarly, I read a lot more novels than math books when I was a grad student. And, going back to my undergrad years, there’s the whole ‘Sanskrit major’ thing.)

That’s my life; what would games suggest will be the outcome? When I make a build like that in a role-playing game, it’s fun enough to play, but never really optimal for progressing in the game. So I’m pretty sure that, if you looked at the great strategy wiki of life, you wouldn’t find my particular career trajectory on the ‘recommended builds’ list. Which is something that I’ve been thinking about with this latest job change: in fact, that’s as good a way as any to thinking about the last parts of my recent “job search and narrative” post. As a result, I’m now focusing on a build that will let me do well with startups, that will present me as an agile server-side programmer who can deal with large amounts of data, and whose checkered past will make him ready to face with equanimity the sorts of surprises that happen frequently in startups. I’m still pretty far away from the recommended startup build—I’m 40 years old rather than 24, I’m not going to be putting in 60–80-hour work weeks—but there’s a certain strength and coherence to it.

The truth is, though, I’m better off not following a recommended build. A recommendation isn’t made in a void: and recommended builds are designed to let you progressing through the game as smoothly as possible. Games have metrics that you can use to measure that progress; life has metrics as well. You can choose which ones to pay attention to, which ones to ignore; and even if you are paying attention to a metric, you can choose how to respond to it. Returning to Dragon Age, that game has per-party member approval meters: you can try to raise them all as high as possible, you can try to raise a few specific ones as high as possible, you can even try to lower them all if you’re feeling particularly perverse! Or you can step away from the idea of controlling them, and instead see them as gauges reflecting your personality, reflecting your nature, reflecting your character. My build may have made certain battles tougher than they would have been otherwise (though, to be honest, it’s probably really my RPG-playing skills that are to blame for that), but I’m fine with that: I’m more interested in seeing my choice of actions reflected in the reactions of those around me and in the tales that unfold.

Which is a pretty good way to think about life as well. GDC just ended, and I can’t imagine a better way to have spent a week: stunning talks, I feel privileged to have been able to spend time with people as I did, and honored to have been able to play a part in facilitating one such meeting. And today I’ve been sitting around the house, working on my pro keys skills, having Miranda show off the underwater house she’s built in Minecraft, picking out tunes on my new guitar, hanging out with Liesl, being glad that Zippy can still make his way around, and I’ll read a few chapters of a Scala book when I go to bed. It’s a good life: if my character build has somehow led me here, it has more than done its job.

• The Game Design of Starcraft II: Designing an E-Sport
• Hybrid Orchestration – Scoring Need for Speed
• The Game Design Challenge 2011: Bigger than Jesus
• An Apology for Roger Ebert
• Message Queuing on a Large Scale: IMVU’s Stateful Event Architecture

9:30am–10:30am: “The Game Design of Starcraft II: Designing an E-Sport”, by Dustin Browder

2005. Dawn of War just shipped: 4 sides, 63+ units, with more to come. Supreme Commander about to ship: 4 sides 100+ units. Starcraft 2 planned with 3 sides, 45 units. (Some of which are effectively identical!)

This sounded crazy to him: units = choices = gameplay = fun. They need more!

The response: this is an e-sport. That’s new, hard to do. Think of this as “basketball 2”. That means it needs to be: watchable: clear, simple, skill-based, uncertain.

Let’s drill down into these. “Clear” is why the artists hate him. He gives an example of an ultralisk: it’s not nearly as impressive as it could be, it would look a lot better if it were bigger. But if he did that, it would hide smaller units (he showed it hiding 20 zerglings), destroying clarity/readability. Especially important in the case of effects: you don’t want them making an imprecise light show all over the screen, you want to know exactly who is affected and whether it succeeded. 

Simple: minimum number of units. For Starcraft, 12-15 units per race. Too many and viewers are confused, pros have to guess, and some units end up functioning as reskins. But: you still need tons of choices with that small number of units. They started by just experimenting with movers and shooters, fiddling with the stats to bring out differences. (Including area of influence, how they move.)

Interlude on upgrades. Banelings are better than marines; but marines + stim are better than marines. So upgrades don’t just make a unit more like itself, they flip relationships. (And that relationship can get flipped again with a handling upgrade.) Or the roach can be upgraded in two different ways: 1 unit, 3 uses.

Skill: micromanagement is important to them. It’s part of the game: an RTS isn’t just a really fast turn-based game. (Also, micromanagement is fun to watch, important for a sport!) And it allows for degrees of skill, degrees of success/failure. Force field example: easy to use it at a choke point; hard to use it to protect a group on the field; still harder to use it to split an opponent force. (And you can do any of these better or worse: a better player won’t leave as many gaps between force fields.)

(Flanking and terrain examples that I didn’t quite understand)

Uncertainty: that’s why the Zerg rush is there. Anything is possible in the first few minutes of the game. A rush is always going to be possible at some point in the game: so why push out the possibility away from the start?

Those are the core values; now on to ripple effects.

Story: as discussed above, units on screen are smaller than would be ideal for narrative purposes. So they exaggerate in the other direction in story art, so you’ll be able to imagine how cool the units are. Similarly, units are tiny ants on the battlefield, so make them over-the-top characters in story mode.

Solo tech: they had cool, fun units, but they overlapped with other units. So they weren’t suitable for e-sport usage, but still valuable content.

Missions: the narrative arc for the e-sport is exposition (scouting), complication (early battles), climax (deciding battle), resolution (gg, post-game analysis). With single player, though, it didn’t work the same way: a real cost to losing an individual battle, so players would play defensively until they had an overwhelming advantage, at which point there would be a long mop-up period. So they added in lots of different mechanics to the single-player game, to shift the narrative arc. E.g. outbreak: night = terror, day = payback. (Still too much mop-up, though.)

11:00am–12:00pm: “Hybrid Orchestration – Scoring Need for Speed“, by Troels Folmann and Charles Deenen

They’re talking about Need for Speed Shift 2: Unleashed.

Charles started:

Development wants cinematic Gladiator-liked score. Marketing wants youth-relevant licensed songs. Traditionally, you separate these two; they decided to merge them into a single hybrid score. Take very popular tracks, reorchestrate / rescore them.

Different music styles: epic = driver’s win, dirty = battle, two others that I didn’t catch in time. (Surreal = preparation, I think, and then special purpose for full-motion-video?)

They did a concept with a single 30 Seconds to Mars track; worked surprisingly well. So let’s go with it! But required signoffs from lots of different people; and its a huge amount of work even with the bare minimum of 10 songs. And very tight pipeline, with serious risk of having signoffs denied late in the process.

They decided to start with a test bed to get early approval from one of the bands, to reduce risk. They had different composers produce sample orchestrations in the different styles, to see what would work. (Same audio tracks, but everything else was different.) Made about 20; sent top 7-8 to band.

And, fortunately, the band really liked it! Kept feeling of the song while reinterpreting it in really cool ways. This helped convince execs and other bands, too. (Eventually, all 10 targeted bands signed off.)

Now Troels speaking:

The Four Noble Truths: everything is suffering, suffering arises from attachment to desires, … (Ed.: one of the more unexpected slides I’ve seen in a GDC presentation.)

And: what does “hybrid” mean? One important consequence: don’t follow a traditional song structure; this is hard! Also, refine concepts: epic alone isn’t good enough: need epic clean, epic emotion. So a specific hybridization for this project.

(Previous example: mismatch between sound, game. Kill your darlings, listen to client / game. Surprised he was invited back.)

Created a template for this hybridization. Focused on percussive elements, also mention of strings and brass that I didn’t understand. (And what is “RMX and deep-sampled percussion”?) Ethnic choirs, custom signature samples.

First example: “Night of the Hunter” by 30 Seconds to Mars. Showed various refinements, …

Second: “Issues”, Escape the Fate. Lots of revisions. What’s the right number of revisions? 7 was definitely too much.

So he hit the wall. How to overcome this? Communicate; find personal joy; make mockups; face the wall; ignore the wall. Took the last strategy: took three days off completely. Sat in his garden, recorded bees, turned them into different songs. (Hi-hat, Hammond, …) Made a pretty amazing video out of it. Also tried various objects: crowbar, light bulbs, coffee pot, playground poles.

Third: “Take a Load Off”, Stone Temple Pilots. Went a lot faster this time, only a few revisions.

Fourth: (unreleased song) 7 revisions, but all small, so not a big deal.

Back to Charles.

Postproduction. Increased clarity, better instrument and frequency separation, more TV-friendly sound, even composer agreed it was worth it.

Post-mortem: how to approach hybrid? Create template, ensure everything connects textually, identify signature sounds, identify rhythmic elements that merge with orchestral and synth elements.

12:30pm–1:30pm: “The Game Design Challenge 2011: Bigger than Jesus”, by John Romero, Jason Rohrer, Eric Zimmerman, and Jenova Chen

Eric Zimmerman (moderator). For this year’s theme, he wanted to merge games and religion: create a game that could be a religion. (Not about religion: the game itself and the act of playing should be a religion.)

Jason Rohrer

Chain World: A humanistic video game religion that someone will play today. Religions used to try to explain physical mysteries; that role has been usurped by science and technology recently. He talks about a detour that I-77 had to take around a town in Ohio because of a fight his grandfather led. Talks more about visiting that town, about things his grandfather allegedly said. Lots of details about his grandfather that he doesn’t really know whether or not they’re true: his grandfather is turning more into a saint-like figure. We become like gods to those who come after us.

His game idea: you control a world, then pass it on to the next player. Game designer is god, he passes the start state to the player, leading to an end state. But what if your end states somebody else’s start state? Each player is like a god to the next.

You want to do this in a game where modifications don’t screw up the playing field for the next player. (So not like Mario, where you modify the world by destroying blocks.) Players might have intent for how they want to modify the world for the next player; players might wonder what the previous player intended with an aspect of the world.

That’s the frame idea; what’s the actual game? Minecraft! A specific world on a specific USB stick. Play the game, don’t erect signs with text, play until you die. Save, pass it on, never play again.

John Romero

What is a religion? Deity, worshippers, devotion. In the beginning, there were lots of gods, one true god emerged @God6502; he had a son @Messiah6502. Follow him on Twitter: first twelve followers are his apostles. They come down to the front of the room; quite a distinguished bunch. Each gets a pad of sticky notes, to gather followers.

The winner: the apostle with the most miracles: some of the sticky notes have star markers. (@SquirrelTweets) But: to win the game, you must kill him, John Romero. (Doom image.)

Jenova Chen

Here are his slides.

He’s Chinese, so supposed to be an atheist. Did lots of research. Chinese believe in gods, but not the same sort of belief that you see in modern religions: a god is an unknown, a value. Dao = way of life, how to live. Recent China: socialism, then developmentism, then consumerism. These three are all about being happy, which seems fairly fundamental. Or: belief in something bigger.

Inspiration: Campbell, Csíkszentmihályi, Darwin.

What drives happiness? Money is useful at first, but beyond a certain level more money is irrelevant. Hierarchy of needs: top is self-actualization, not addressed by money.

At the end of the hero’s journey, he returns, giving something back to the community.

What is our purpose? He wants one that works for primitive humans, even for nonhumans. Circle of life: propagation is the more interesting part. These days, propagation of ideas is more important.

But what ideas should we propagate? Evolution says: look at the ones that survive, refine them. How does selection happen? Unknown: god. (Editorial note: not really, no…)

TED: Ideas worth spreading. But they’re not good game designers: the website is very passive, even the slogan is. TED: Influence with your ideas. No ranking for videos: rank by view count, or better by number of people inspired by them. Give each video a page, showing whom you’re influencing. Twitter follower count, badges in a Chinese twitter-like site.

Badges alone aren’t a game: you need a feedback loop. So: badges / points lead to promotion system that help draw other people to watch your video.

Propagationism.

(Rohrer won.)

2:00pm–3:00pm: “An Apology for Roger Ebert”, by Brian Moriarty

(Here’s the text of Moriarty’s talk.)

“I am, in fact, Professor Moriarty.” This is an apology not in the sense of anything done wrong, but in the sense of a defense.

(Discussion of 2005 Ebert article, 2010 flaring up of the argument.)

Why return to this? He wants to discuss Ebert’s claim that there isn’t a game worth of comparison with the treasures of world literature, movies, music, paintings.

Discussion of painting: Northcote, Chess Players, c1730. Two chess players: the game industry, self absorbed, satisfied. The golden boy is art itself, looking at us, pointing at a paper containing his secrets.

Read lots of art history; never saw games mentioned as art. (Ed. Nobody stood up for go? Oy.) Math is elegant, but nobody confuses mathematics with art, they’re different categories! Considering games as art is radical; then again, the idea of great works of art is also radical, only 500 years old.

Photography, movies entered realms of art relatively recently; why shouldn’t video games? Because games are old: if chess and go aren’t art, why should video games be?

Interlude: we know what video games are. But we don’t know how to define art, let alone great art. C.f. Duchamp urinal. Also, games can clearly contain great art from other media. But that’s not enough: mechanics and affordances are key. Can mechanics and affordances be considered art?

(Taste, intersubjectivity. Not all movies are Art.)

Eliciting emotion isn’t enough for art. Art is about attraction. (Ed. really??) But how to distinguish sublime art?

Kitsch. Is it art? Somebody claims: yes, art with three characteristics. Highly charged with stock emotions. Instantly and effortlessly recognizable. Does not enrich our associations. Nearly all popular art is kitsch. (Bombast: all adaptations are kitsch? Oy.)

More on games as kitsch, whee.

Celebration of kitsch = camp. Ultimately an evasive strategy.

Big studios won’t make art. Indies won’t. Who will make art? Those who would make art anyways: the artists. Warning: don’t just follow the trappings, then you’ll get something arty.

Technology of film largely stable for more than 100 years.

Structural reasons why games won’t produce sublime art. Ebert talks about direction of artist, inevitability of meaning. (Oy.) Romantic point of view. Schopenhauer: free will and individual choice are illusions, desire a prison. Leap off the wheel of desire via the contemplation of sublime art. Transcends will, frees us from agony of contingency and causality.

“Flow is an an-aesthetic.”

If the purpose of sublime art is to solve the mystery of choice, then …

Sublime art is the still evocation of the inexpressible.

All sublime art is devotional.

Edit: I thought Emily Short’s discussion of this talk was quite good.

3:30pm–4:30pm: “Message Queuing on a Large Scale: IMVU’s Stateful Event Architecture”, by Jon Watte

His slides:

Want: any-to-any messaging with ad-hoc structure. Lightweight (in-memory) state maintenance. Added queues as a building block, with two kinds of messaging: events and states. Integrated into a bigger system.

User to queue: connect, listen, send. Queue to game server: validate users/requests, notification. Game server to queue (didn’t catch it).

Design goal of 1M simultaneous users. (10x current use.) Real-time, meaning 100ms end-to-end. 20M queue creations/day.

Existing solutions didn’t work. (Wished they could buy Gtalk, AIM, etc. solutions!) Inspired by mochiweb: 1M users on a single machine, written in Erlang.

Implementation.

(Journey of a Message diagram: send to queue, validate, forward to other users listening to queue.)

Queue: multiple mounts (chat – message; scores – state; subscriber list).

One machine isn’t enough: doing some math on volumes and memory speed, would take over 3 seconds per message. So need to scale across machines.

Scale in two dimensions: gateway machines and queue machines, connected via a consistent hashing mechanism that allows moving chunks of queues via a central map of buckets to nodes.

Erlang. I’ll skip the details, but: basically, custom designed to solve their problem.

(Dozed off some: load balancing; marshaling via protocol buffers.)

Have a boss node keeping track of what gateway, queue nodes are doing. Looks like a single point of failure, but things keep running without it, you just can’t add more nodes until the boss is restarted.

Message could go out via a different node than where it entered; led to time skew. So sent messages out via entry node.

Hot add node diagram: make sure to forward messages while move is in process.

Problem cases. User goes silent; detect via ping. Reconnection of user, possibly to a different gateway: user-specific queue arbitrates. Node crashes (yet to happen in production, go Erlang!): state is ephemeral, user might get logged out. Gateway crashes: client reconnects, gets resent missed updates, application above queue API doesn’t notice. Sometimes want reliable messages; higher level API stores it in database. Firewalls: use proprietary protocol on port 80/443.

Build and test. Continuous integration, continuous deployment. Erlang supports in-place code updates, but too heavy for them; use failover instead.

Future: replication; scalability limits; open source what they can.

I broke two talks out to their own posts:

• “Classic Game Postmortem – Out of This World/Another World“, by Eric Chahi
• “One Falls for Each of Us: The Prototyping of Tragedy”, by Brenda Brathwaite

The rest:

• “Biofeedback in Gameplay: How Valve Measures Physiology to Enhance Gaming Experience”, by Mike Ambinder
• “No Freaking Respect! Social Game Developers Rant Back”
• “Experimental Gameplay Sessions”

10:30am–11:30am: “Biofeedback in Gameplay: How Valve Measures Physiology to Enhance Gaming Experience”, by Mike Ambinder

Current control schemes: one dimension of input, map intent into control schemes, lacking feedback mechanism. Add in player sentiment, emotional input, get more immersive and calibrated game experience.

Emotion is a subjective internal state, usually a response to external events. A vector: has both magnitude (arousal) and magnitude (valence). Correlates with physiological signals of various sorts.

Heart rate. Beat to beat interval of blood flow; measure both baseline and deltas over time. It’s a cheap, easy way to get at arousal; not so easy to get valence. Also, its prone to movement artifacts, and the onset after stimuli is delayed.

Electrical resistance of skin. Measures arousal; get both responsive and anticipatory spikes with low latency. Hard to get valence, though; can’t always associate spikes with events; range varies across subjects.

Facial expressions: track muscle movement. Get both valence and arousal. Not well automated yet.

Eye movements. Fun fact: when our eyes are moving, our brain isn’t processing. So if you measure eye movements, you can find windows when you can update the screen without the player seeing! Index of attention, arousal (pupil dilation), reliable. But very expensive, requires lots of analysis.

EEGs: electrical potentials of the brain. Different frequencies represent different emotions. Get arousal, valence; expensive, intrusive, noisy, though.

(I took a nap during the rest of the talk: it wasn’t bad, but I was quite tired. He showed using these to affect the AI Director’s behavior in Left 4 Dead and using eye tracking for control in Portal 2.)

12:00pm–1:00pm: “No Freaking Respect! Social Game Developers Rant Back”, by nine speakers

This was largely excellent.

Brenda Brathwaite: Resists the title: won’t turn against her fellow designers who have supported her for 30 years. (History lesson.) We stood together because we love games. … Wish I could have recorded end of that, really something.

Update: fortunately, it was recorded! Here’s the transcript, and here’s the video.

Brian Reynolds: Really boring.

Steve Meretzky: No, you can’t #%*$&ing design. Execs who think they can design; execs who think that game design isn’t needed at all! 10,000 hours of learning experience is way low, in his opinion, and everything is constantly changing. And then the rant really heats up…

Chris Hecker: Potential Unreached. Was going to rant about gamification, but doesn’t care about selling shoes. Games as a means to save the world is great, but games are valuable as an end. And we’re not reaching their potential: lots of emotional headroom we’re not reaching. Want “lifification of games”. Games currently can’t express the difference between Seinfeld and Friends. (The Sims is the only game that looks like either.) Want to increase our expressive range; need more human interactions, we don’t need more aliens and orcs. Doesn’t have to be difficult to implement, or result in casual games. We just have to try.

Scott Jon Siegel: You’re Doing It Wrong: Why the Last Few Years Have Not Been Awesome Enough. Never gets feeling of a really awesome system in social games. In 2009, had Parking Wars, Bejeweled Blitz, Mouse Hunt. Fault of Farm Town. Led to current great social game fallacy. Need to rethink the last two years of social game development, start over.

(His slides are up.)

Mini rant: Jane McGonigal et al. Games as escapism is bullshit.

Trip Hawkins: Fear that we’re all lambs to the slaughter. Licensing agreements. At least Nintendo had the decency to tell us how they were going to screw us. Don’t try to be the winner of American Idol.

Ian Bogost: Shit Crayons. Amazing performance.

1:30pm–2:30pm: “Experimental Gameplay Sessions”, by fourteen speakers

Focus on experiments: in search of dynamics, or new meanings.

Hanford Lemoore, Maquette

It’s about recursion. The game world contains a model of itself inside one of the buildings: changes in one are mirrored in the other. What’s more: can take block out of model world, put it in outer world, and vice versa: effectively shrinks / enlarges objects. (A key turns into a bridge.)

Michael Brough, Sense of Connectedness

Game board is a brain, with no explanation. You have to make and test hypotheses over and over again. E.g. you explode at some point: why did that happen?

Nicolai Troshinsky, Loop Raccord

Raccord: the feeling of continuity that you get when a cinematic cut works well, looking smooth and continuous. The game shows you a chain of video clips: you have to stop and start them so that it looks like objects are passing smoothly from one to the next.

Stephen Lavelle, Opera Omnia

There are several time manipulation games: all about cooperating avatars to modify the present. Opera Omnia: the present is fixed, need to find a better explanation for how we got here. The playing field is cities: you can control migration between cities, and there are various events (e.g. famines) that happened in the past that affects population as well. Takes an Orwellian turn when a population segment was massacred in the original history, but the population migrated in an alternate history.

Jason Rohrer, Inside a Star-Filled Sky

Recursive shoot-em-up: it’s gotten a fair amount of coverage recently, so I won’t go into details here. The death mechanic resets a level when you progress; that seems punishing, so an earlier version kept your progress. But then a simple “always move towards the exit, never shoot” strategy works; that’s boring, prevents learning.

His explanation for why he did the game basically boils down to conveying the experience of yak shaving.

Agustin Perez Fernendez, Mantra

An experiential game about meditation. There’s an endless spiral that you have to avoid; it makes a noise if you hit it. As you do better, the visuals go away; want to play guided by the mantra and the sounds that happen when you make a mistake.

Andy Schatz, Experiments in User-Generated Content

Started with The Abrupt Goodbye. It presents a conversation tree, with up to five answers. With fewer than five, it gives you the opportunity to enter a new response; the game ends when you do that, and adds your response to the list of possibilities. Unpopular choices get culled; also, there are male and female branches, so both sides of the tree are user-generated.

PlayPen. Collaboratively built world: comes with a graphics editor, users can edit screens and add hotspots.  Infinite Blank. A platformer: when you come to a new area of the level, you own it and can do whatever you want. PlayPen has collective ownership, with all the good and bad that that brings. 

6:00pm: Dinner

The annual game bloggers / journalists (with a few developers sprinkled in for good measure) dinner; I had a fabulous time. I spent most of it talking to Tami Baribeau and Dan Apczynski.

Thursday 4:30pm–5:30pm: “One Falls for Each of Us: The Prototyping of Tragedy”, by Brenda Brathwaite

My favorite talk of the conference, or indeed any GDC that I’ve been to. Brenda said that she now gets introduced as somebody who makes games that make you cry; I can attest that she gives talks that make you cry.

This talk was a “pre-mortem” for the game One Falls for Each of Us. Which makes her anxious: this game is a personal effort instead of a group product, and her personal design process is odd.

It’s part of a series called “The Mechanic is the Message”. The first is about the slave trade; she made it for her daughter. The second is about the Cromwellian invasion of Ireland. Which is more related to her personal family history. The third is Train, about the Holocaust: zeroing on complicity, complexity, regret. The fifth is Mexican Kitchen Workers. Then Cité Soleil, about day and night violence in Haiti. (People playing two different games on the same board.)

All these games use the same little people figures: the same underneath, different colors on the surface.

The fourth: One Falls for Each of Us.

These games were originally design challenges: she was teaching at a college, didn’t have access to programmers. Interlude: talking about a conversation between photographers about choosing whether to take the picture. Alien to her: you don’t generally get to choose not to make games.

Tragedy as a topic. At first, she thought it was alien to games, but not so. Puerto Rico, Colonization; but Super Columbine Massacre and Six Days in Fallujah are anathema to many in our society. And she doesn’t have to worry about topics, packing, time, schedule.

She liked the potential of these games; others were less impressed. Commenters on blogs reacting negatively; Indiecade award was special, though.

Her process of approaching tragedy: she believes deeply that the game already exists, she needs to find it. And that she’ll be able to do so: it will take some thinking, but she has time, the game will reveal itself eventually. (As opposed to, say, Ravenwood Fair: she feels that she makes that sort of game rather than finds it.)

Interlude on art: Richard Serra, Jackson Pollock. Jackson Pollock would spend a lot of time just circling the canvas.

Taking a road trip back from Indiecade: what would it mean to leave her home? Really hard for her to find an entry point. But: where there is a human-on-human tragedy, there’s always a system. How could she find it? She spent a lot of time studying maps.

She had a discussion on Twitter about appropriation of culture.

Finding the system: how did they “remove” these people? How did these people respond? Why did they do this? What was their motivation? What resources were they given? What were given up?

Interlude on Irish soldiers in the US who were told to attack Mexico: they instead fought on the Mexican side. Reports of numbers told by Americans and Mexicans are radically different. Don’t trust any of the history of this stuff.

Back to appropriation and systems. You’re playing it as a white guy, not as an Indian. She thought maybe the board should be the USA. Previous games made you feel complicit: how to do that here?

You’re playing a white man; four of you, removing five Indian tribes. With a game of massive scale: the game will have 50,000 pieces. So a piece represents a person: if you want to play the game, you’re going to have to move a lot of pieces.

The subconscious and symbolism. The pieces come in bags of 100. Then, she opens the bag, dyes them: the bag looks like a hamburger wrapper. They dry out on newspaper; one session was right after the Haiti earthquake, making some amazing juxtapositions of red painted figures and photographs of Haitians in the earthquake.

Concerns (or where it is now). She wanted to have it finished by GDC, she had her weekends planned out. But then crunch time intervened. Why did she let that other game take precedence over this game of her own heart? She won’t do that again.

Where it starts: part 2. In fall 2006, she was attacked in a horrific way, and laid in bed for a long time after that. She’s trying to understand what happened, why they did that. She was thinking about making a level in a game that would represent this. She made a game in her imagination, exploring pain as a system.

Then she played The Path. Which gave her a release, an amazing moment. It made her realize games can do anything.

Thursday 9:00am–10:00am: “Classic Game Postmortem – Out of This World/Another World“, by Eric Chahi

This was a look back at the making of Another World.

Overview of the creative process. Freedom under constraint: an improvisation process.

Initial context. July 1989, the Amiga era. He’s 22 years old, but had written a lot of games; taken 3 weeks to 6 months, none really successful. Dragon’s Lair had just been released: how to do this?

2D game based on polygons. Cover lots of the screen with not so much data. Also wanted to use rotoscoping techniques, inspired by some new hardware. But: is it possible to draw polygons at the right speed? Experimented, yes. So graphics unit: polygons and only polygons, that’s a key constraint. He was obsessed with this: how would a potato look in polygons?

At times, he used “pixigons”, polygons the size of pixels. So the first level took too long, doing pixel art in an obtuse fashion. He ended up using bitmaps for the backgrounds, to increase detail, but only ten bitmaps in the whole game.

Create a 2D game with a cinematic feeling?

He didn’t have suitable tools available, so he had to create an engine and tools from scratch. He wrote a polygon editor, and an interpreter for a homegrown scripting language for the game logic. (Including animation!) Shows the main character in the editor, including a demonstration of groups of polygons. (E.g. the head.)

Fusion between code and graphics: you can modify the graphics in the polygon editor and see the interpreted code change, or vice-versa.  It was a very simple language, with only 256 possible variable names; he ended up writing down the meanings of variable names on paper! The engine had 64 tracks, each of which could run its own code. (Like a multi-track audio mixer, I guess.)

December 1989: tools and engine were usable, albeit flawed. One flaw: no common data shared between levels! So he copied data back and forth, which was a nightmare when tuning: each change in Lester’s behavior had to be done five times.

Did the initial animation. Polygons worked well; rotoscoping, not so much.

Tried hard to listen to his inner self. Including surprising himself: what would he expect as a player at a given moment, how can he subvert that expectation? E.g. when player is transported initially to the other world, initially thought that the player would appear on the surface, but much more surprising if he appeared under water.

The basic gameplay mechanics were inspired by Karateka.

16 colors in the palette. Which meant that he needed to have multiple uses for colors: e.g. used the main character’s flesh color for sunset highlights. Using black hair would have been useful to that end; but then the character would have looked too much like Eric himself, which would have been disturbing! Red hair loved that latter problem, while still being a reusable color.

He used parallel action in the background; but then the background action comes to the foreground (the lion appears), with a cutscene ad punctuation, then varies up the pacing in the subsequent chase, backtracking, rescue by a hooded figure.

That ends in a cliffhanger; the next scene starts by removing the hood (in a different location), so he could learn what’s under it! And then friendship gets introduced, including the only closeup of Buddy’s face.

Also, this level introduces both weapons and shields. That combination turned out to allow a lot of interesting gameplay combinations. (Especially whe you throw in the slow shield-destroying plasma shot.) Do you use a fast shot, take the time to set up a shield, take still more time to destroy a shield?

Also, going from the top to the bottom of the screen: he’d initially planned to use an elevator, but a teleporter felt better.

At the end of the jail level, it was clear that you’d have to meet Buddy again later.

December 1990: 17 months in, only 1/3 of the game is done. So he needed to work faster; he focused on puzzles that used the same building blocks he’d already established. The frame of the story ended up being a series of meetings and separations between Lester and Buddy. (That wasn’t the plan at the start: improvisation.)

He used separation of foreground and background more: that gave a cut scene effect without interrupting gameplay. And played more with pacing.

Publishing. He met with somebody at Virgin Games: they tried to convince Eric to make it easier by converting it into a point and click adventure. He was tempted, but decided not to; went with Delphine Software, who were supportive of the existing software.

June 1991: time is running out (it was scheduled to be released in November).  How should he end the game? He went through the game so far, and drew a map of key past events; he decided to play with the pace, leading to the area scene.

The cover illustrations of his previous games had been particularly unsatisfying. He was already passionate about illustration, and Delphine Software was willing to let him illustrate the cover himself. But he didn’t have time!

Also, they weren’t doing enough play testing. They found a few issues, but it was still unbalanced. Later, Interplay ported it: they polished some aspects, but also wanted to make the game longer, more difficult.

Interplay wanted to change the music, which he really objected to. They had a long war via fax, which eventually led to Eric sending an infinite fax, consisting of a looping strip of paper in the middle of the night, saying “keep the original intro music!” Interplay didn’t change their mind, but Delphine pointed out that Interplay had no legal right to change the music.

Console porting led to a bit of censorship, about an alien butt-crack. He considered sending an infinite fax, but decided to remove three pixels instead.

Eric was exhausted at the end, which is probably why Lester is almost dying at the end of the game.

He’s surprised at how long the game has lived: in fact, its being ported to iPad now!

I’ve broken out two of today’s talks into their own posts:

• Clint Hocking on “Dynamics: The State of the Art”
• Jason Booth and Sylvain Dubrofsky on “Prototype Through Production: Pro Guitar in Rock Band 3“

The rest:

• “Video Games Turn 25: A Historical Perspective and Vision for the Future”, by Satoru Iwata
• “GDC Microtalks 2011”
• “Seven Ways a Video Game Can Be Moral”, by Richard Rouse III
• “Designing Limbo‘s Puzzles”, by Jeppe Carlsen

9:00am–10:00am: “Video Games Turn 25: A Historical Perspective and Vision for the Future”, by Satoru Iwata

I actually liked Iwata’s 2009 keynote; this one, not so much.

25 years ago: no industry, just a hobby. Would wear lots of different hats: game designer, artist, sound engineer. Lots of fun; made almost no money, what we produced was primitive. “Video game cavemen.”

Now: more graphics power, more memory, much more costs. Much larger teams, longer timescales. Fortunately, more people are playing games: Nintendo’s basic strategy is to expand market. Sales alone not the whole story: when are machines shared? In 2007, 45% of US population had played a dedicated game console over the last year; in 2010, 62%. More room for growth in Europe, and then there’s emerging markets.

Social network games are different from video games of a social nature. Space War; multiple component ports; wireless communication on handhelds; online play.

“Must-have” comes from three sources: hardware (e.g. Gameboy; not easy); game; social appeal of connecting with other players.

Mario always evolves. Pokemon popular because of social nature. Tetris first video game to attract a female audience in a meaningful way. The Sims: maybe not even a game, no way to win or lose, but phenomenally popular.

Universal appeal. First Kirby game went against then-current trend in action games of being very difficult: designed so that almost anybody could finish it.

Selfishly, hopes Nintendo 3DS is next must-have: because of technology, because of games, because of social appeal. Built-in applications are designed to increase social appeal, and to encourage people to carry the 3DS everywhere to get passive data transfer.

Now Reggie is on stage. Says nothing interesting. Iwata back, game teasers. Then:

Three concerns. First: craftsmanship. Often gets lost as projects get bigger, more complicated. Second: talent development. Too much specialization, hard to assess entire personality of a game. Third: too many games, often cheap or free, so hard to make enough money to survive. is making high-value games a top priority, or not? Smart phone / social network platform owners care more about quantity than high value.

Getting noticed: capture attention immediately; easy to describe unique nature of game to others. With these, reach tipping point for word of mouth. Innovation: make the impossible possible. Trust your passion.

12:00pm–1:00pm: “GDC Microtalks 2011”, by ten speakers

As always, these were excellent, and impossible to summarize: it’s just an experience that washes over you.

Richard Lemarchand: intro. Microtalks means 20 slides, 16 seconds each = 5 minutes 20 seconds. Theme: Say how you play.

Michael John: is the father of computer games the computer, or games? Code fear pulls us to latter, but former is correct. All games are played; not all play is games. Mention of education. Kids should be making computer games; everybody should know how to program. Making game with his daughter.

Jamin Brophy-Warren: Kill Screen! Think about video games as (design) objects. What is a toaster? Lash-up of various properties/components. Games are objects with stories; game players are storytellers. Objects increase in value by being linked to stories. Not currently good at telling stories about games to those outside of our circle. Lacking a common narrative tongue. Overcome the dinner table story, embrace our stories. If we don’t tell our stories, they fade into the ether. Here’s the text of his talk.

Naomi Clark: Tarot decks, I Ching. Divinatory systems give rich matrix of ideas to associate with. Social games. Games of labor. David Sirlin prefers games of skill. And then there’s the fantasy of games of chance. Games of labor also have a fantasy. (As do games of skill: “adolescent delusions of badassery”.) Game designers’ fantasy: fantasy of control. Leave more empty spaces in our games, more pauses in the experience of play?

David Jaffe: Personal gaming setup moving more to portable space. Gap from turning on (non-portable) console to playing. Low-end: 1.5 minutes. High-end: 3+. Lots of other options without that boot problem. Sleep mode? Restrict updates? Shorter games? Multiplayer: best one-on-one, worst with large teams.

Colleen Macklin: Playtesting: the call of the wild. Don’t want to domesticate games too much by excessive tweaking, though. Game we played: want to stay in minority as long as possible. (Didn’t work too well…)

Asi Burak: Text adventures.

Jason Rohrer: Boredom has survival value, perhaps, but not great in games. Don’t want a spoonful of sugar with medicine: want fundamentally delicious medicine. Paintings engage for seconds; music for minutes; movies for hours. Latter engages more you than former. Engagement with plot also has survival value. Games super-engaging, lasting dozens of hours: you can’t even knit while playing them. Survival value of engagement with challenge is obvious. Fight against challenge in games is as hopeless of fight against plot by avant-garde movie directors. But need more plots. Similarly, need more varieties of challenge, while embracing it as potent expressive tool in its own right.

Brandon Boyer: Originally, approached topic with melancholy: more interested in David Foster Wallace, Spalding Grey recently. But then: Little Big Planet, Retro Game Challenge as tragedy. Power of aesthetically pleasing abstract systems. …

Brenda Brathwaite: Wow.

3:00pm–4:00pm: “Seven Ways a Video Game Can Be Moral”, by Richard Rouse III

Wednesday 3:00

Last year: how a video game can make you cry. Sort of a joke talk; this year, on morality, more serious. Moral storytelling a rich tradition, and not easy when done well. Clint Hocking 2007 talk: great game with great systems helps a player explore themselves. He mentioned Ultima 4. That’s 1985; what has changed in the intervening 26 years?

1) Clarity of Intention

Romeo and Juliet lays out the scenario right at the start, with the two warring houses, star-crossed lovers. (Editorial note: spoilers right at the start! Shocking.)

Video games also signal moral issues: Star Wars games saying “Choose Your Path” on the back of the box, morality meters in BioWare game.

Flip side: don’t always have to make your intentions clear. E.g. Rod Serling positioned The Twilight Zone as pure entertainment, even though it wasn’t. Games can do something similar, e.g. Blade Runner game adapts outcome to how player is playing, with no meter in sight: make players feel like they’re doing the right thing.

2) Multiple Points of View

Star Trek example. From original series, and Next Generation; recent reboot movie left moral issues on the side. (But Battlestar Galactica reboot faces moral issues head-on with multiple points of view; answers are much less tidy than in Star Trek.)

Game example: Alpha Centauri. Different factions make different choices in how to build your society, other factions would respond from their own perspectives. The game designers deliberately didn’t take sides between factions.

3) Redemption

Twilight Zone again: characters make bad choices at the start, but learn something after their journey through the zone. (At least if Rod Serling liked the character…)

Mass Effect 2: two independent meters, filled up slowly: largest choice is 45 out of 1900. You want to fill up one, so are encouraged to chip away in one direction. In contrast, Fallout 3 has a single karma meter that you can completely trash with a single early choice: this sets up the possibility of a redemptive journey.

4) Complexity

The Man Who Shot Liberty Valance. Jimmy Stewart wants to uphold the law, but is notorious as man who shot Liberty Valance. Except he didn’t, John Wayne’s character did. Neither of those two is the good guy or the bad guy.

BioShock: Andrew Ryan plays role of villain, but not clear that he did anything villainous. Tenenbaum portrayed as good character, but she did concrete bad things early on. (In contrast, save/harvest is a lot shallower.) BioShock 2 has you decide to save or kill three characters; two have tried to kill you, the third wants you to kill him. More complex, but the “Savior” achievement undermined this complexity: the game’s creative director wished he’d removed it. Similar achievement in other direction in Red Dead Redemption.

5) The Quandry

Example from The Wire: drugs out of control, destroying a city, so police decides to ignore it if it’s in a few limited areas, improving rest of the city. Example from a movie where a kid was kidnapped out of a bad life, into a good one.

Not good example in video games. E.g. No Russian level: you have the choice not to shoot at all, but not more meaningful choices. Train is more successful.

6) Thoughtfulness and Respect

Never Let You Go: doesn’t treat some surface issues directly, instead more obliquely in the context of exploring the characters’ stories and grappling with their short lifespans. In games, The Sims: looks materialistic, but items will fail catastrophically eventually, giving a disincentive to buy for more experienced players.

7) Medium, Genre, and Message

The Grapes of Wrath. Tom Joad has to leave his family to avoid getting them in trouble with the law. Bleak departure speech in the book; movie version of that speech has a much more uplifting tone. And then Bruce Springsteen wrote it into a song; closer in tone to the book, but more lyrical. Rage Against The Machine performed the same song: Tom Joad is going to kick some ass! What would video game version be like?

Final thought: Truffault version of Farenheit 451. Interactive TV scene: looks like a superficial video game choice.

We’ve seen techniques; techniques are the easy part, committing is the hard part.

4:30pm–5:30pm: “Designing Limbo‘s Puzzles”, by Jeppe Carlsen

The game has minimalistic design: no levels, no cut scenes, no power-ups, two-button controls.

Puzzle design principles: challenging problem solving, simple elements, few elements, complex problems but simple environments, no repetition.

Showed a chain puzzle. Need to get chain swinging properly so that, when you set it in motion, you’ll be able to grab it and use it to swing over a dangerous area. Only three elements: chain, button to control movement, dangerous ground. But still not super easy: need to experiment and analyze failures to solve.

How develop the puzzle?

1) Predict the player: how will they approach the scene? Come in from left, almost certainly press panel when passing it. See chain slowly moving left to right, try to get on before it’s too late.

So: need to be fast enough to catch the chain? Try and fail, but learn something about environment while doing so.

If chain had gone right to left at start instead of left to right player would instead have gotten on and started swinging right at the start, immediately getting much closer to the solution. So that would make the puzzle too early.

The player is my enemy: devious trick. The player is my friend: accessible environments. Usually start out too devious, make it simpler. Showed earlier version with two switches and a movable block to stand on; way too complex, but while playing around with it, realized that key trick of the more complex version is setting the chain swinging to make it possible to jump to it from a distance. Then simpler version with the final elements, but missing the key initial misdirection.

The correct solution must be easy to execute: worst case is if player concludes that a correct approach he’s doing is not possible. Conversely, wrong solution strategies must clearly communicate that they are wrong, so you learn from your death.

Now: level editor demonstration!

Place boy, floor; boy automatically runs around on the floor. Add slope, crate. Boy tries to push crate, but it’s too heavy. Fiddle with weight, boy then pushes it up the slope. (Very impressive automous boy.)

Example of trigger modifying behavior of objects. Timer script example. Changing gravity example. Have gravity periodically flip up, down.

Great for fast prototyping; not easy to read scripts, though, even in simple cases. All the symbols for a puzzle are on the screen at all times. So once puzzle is pinned down, often replace script with a few lines of code. (He later showed a real in-game puzzle where the script looked unworkably complex.)

Wednesday, 1:30pm–2:30pm: “Prototype Through Production: Pro Guitar in Rock Band 3“, by Jason Booth and Sylvain Dubrofsky

The slides are available online.

In 2008: music games were a big thing, needed to innovate.

Harmonix has this idea of The One Question that they focus work on a game around. For Guitar Hero: is it rock? Rock Band: is it an authentic band experience? Rock Band 3: used the same question, but make it more authentic. Which leads to: pro guitar, have people play on a real guitar, really learn how to play!

First, 3 months of early exploration. Question: is the problem space to teach people how to play guitar, or to pay RB with a real guitar? These don’t actually intersect that much. Target audience: hard/expert RB guitar player.

Use the illusion: mute/unmute the sound of real tracks, so the first time you get it right it sounds great. This is very unlike learning to play on a normal guitar, where you sound awful for a long time.

How to notate frets and strings? First idea: fret relative. Columns represent frets, represent strings some other way. Didn’t work so well, so tried having columns represent strings. Worked a little better, still issues to work out.

And some early constraints. It had to: display notes, chords; be pitch accurate; target non-musician RB players. It didn’t have to: work with bass; work with all songs; work in all game modes.

This was enough to give them something to work with when they had time, and to assemble a small strike team. Benefits: implementers make decisions. Focused meetings. Seating proximity. 

How they prototyped. No good hardware solutions: cost, latency, accuracy problems. Do whatever works best for now, use info to inform later decisions.

Question: how to communicate what to play? Approach: focus on building muscle memory, not music theory. Traditional notation good for conductors, highly compressed (e.g. key signatures). Guitar players use tablature instead: physically centered. But it has more problems: doesn’t work well with chords, rhythms. Third possibility is chord charts, but only works well with chords.

Need something else. The notation should be physically centered, compressed enough to be recognizable at a glance, work with time.

Different chords have different shapes on your hand. Can play same shape at multiple places on fret board, how to represent that? Also, what about riffs, loose strumming, arpeggios? All opportunities for compression.

So: new notation system, string relative. Should it be horizontal or vertical? All music notation is horizontal, so it must be better. First version could work either way; they found horizontal moved too fast, hard to represent shapes. So vertical was better.

Song selection for early prototypes. Did songs that would definitely work, e.g. I Love Rock and Roll. Also simplifies early prototyping if doing a 3-chord song!

Next questions: how teach chord shape? What info do they need to understand what to do with their hand? What else do they need to know?

First idea: inline training into songs. Really jarring, though. Next idea: chord book. Tried virtual hand, but players didn’t look at that. Players just need to know what they need to do and what they’re doing wrong.

Added in a “wait mode”: when learning a part in real life, you pause periodically while figuring out what to do next. So they’d do the same thing, where the game would pause while you put your fingers in the right place.

They play tested with various internal groups: little musical experience, lots of musical experience, little guitar experience, lots. Asked how fun it was; players weren’t sure that was the right question, but they persevered.

Big question that playtesters had: what is their left hand actually doing? So they wanted to show the shape hand was actually in.

Still problems: upfront learning, complex chords, screen real-estate, not all songs work well. Won’t be able to solve all of this, but wanted to chip away.

Had done enough to inform hardware requirements: need to know what left hand is doing, need low latency, need low cost. Ideal is actual guitar, but that has problems: never been done, could be expensive, strings break. So maybe plastic guitar approach? Decided to pursue both approaches, and ended up shipping both. 

Prototyping suggestions: reduce team size as much as possible. If an idea / issue keeps on coming up, you need to try it. Don’t skimp on low-hanging fruit.

Cycle: establish core goals and constraints, hack it in, playtest, repeat.

Prototyping took 7 months; on to production. (Which took 13 months.) They were confident coming out of prototyping, decided to raise the stakes. Do it in every song, every mode; anybody can learn easy, every note is in expert. Training on all song on all four difficulty levels, plus bonus music training.

Still need to figure out: standard RB stuff (hopos, solos, …), advanced song techniques, song authoring.

Problem 1: hardware. No MIDI drivers. Seven bridge modules to translate from MIDI to Xbox. Eventually got 7 of the plastic controllers, 3 of the real ones.

Problem 2: late content. Don’t pick all of final setlist until shortly before shipping. Decided to pick snippets of famous songs, to shake out issues. Famous songs, songs that should work well, songs that would stress the system.

Authoring solidifies: easy, medium, hard, expert guidelines. (medium simple chords, hard still parseable in real time.) And 17- vs 22-fret guidelines.

Worked on general theory lessons, too.

Prototype to production took a lot longer than expected.

Problem 3: slow progress. Increased team size, so no shared history. Needed more external focus.

Got back on track: refocused on target audience. Switched to short-term deadlines.  Pulled playtest dates forward to expose problems sooner.

Playtest revealed lots of little issues, and the chord book wasn’t working as well as they’d hoped. But a lot of things worked well; if they could nail those, they’d work well with their core audience, move on to more advanced stuff.

Added numbers to hand shape; pulled chord learning into songs. Then that gave them time to implement a lot of wishlist items.

I asked about the lack out auditory feedback for mistakes. They thought about it a lot, but decided that preserving the illusion was so important that they wouldn’t even allow it as an option.

The entire day posts are getting too long‐Monday’s was almost 4000 words—so I’m going to break talks I particularly liked out into separate posts.

Wednesday 10:30am–11:30am: “Dynamics: The State of the Art”, by Clint Hocking

This is my favorite talk of the conference so far; I really hope he posts his slide deck and more thoughts, because I’ve only barely begun to process it, and I’m sure there’s a lot I missed. My notes:

A question Chris Hecker raised in the 2009 GDC: how do games mean?

In film, there’s something called the Kuleshov effect. Audiences read emotional response from context: an identical actor in an identical scene (literally identical, same film spliced in twice) is read differently based on adjacent footage. Editing is key in generating core meaning of film. Without understanding that, cuts would be at odds with higher-level meaning; we’d avoid cuts, do wide-angled shots, avoid opening and closing scenes while focusing on characters. Film would look like stage plays, but missing the fundamental power of that medium.

So: how do games mean? Answer: via their dynamics. Which are the run-time behavior of mechanics.

E.g. to whip in Spelunky, you need to raise it before you can hit. Leads to atmosphere of deliberation.

Does meaning come from rules governing the whip, or the way the player plays using the whip? Problematic word: “play”. Games are like player pianos. Different in that the player piano can play by itself: think instead of a player piano roll that’s half of a duet, expecting a human to play the other half. You can weight the piano roll versus the human contribution in different amounts; for video games, both parts are always present.

Splinter Cell (original and Chaos Theory) have meaning more on authored side; Far Cry 2 more on player side.

Chaos Theory is about chaos theory: sensitivity of systems to small changes. Sensitivity, proximity, fragility. Both Splinter Cells; original forced player to follow guard, use thermal vision to read finger prints on keypad. In fact, if you were too good, followed closely enough to not need that, you’d get a game over. Chaos Theory loosened that sort of restriction: use thermal visioning, follow guard, interrogate guard, hack computer, hack door. So add in possibility of domination and precision as meanings.

Far Cry 2. Original concept: human social savagery more savage than savagery of tooth and claw. And that’s still there: can mean that its horrific, intimate, shameful, in Tom Bissell’s playthrough. But in Ben’s permadeath playthrough, took safe options more, so reserved, safe, boring.

For sale: baby shoes, never worn. This abdicates as much as possible in a story to the player, while leaving an irrefutable meaning. 

Tetris. Dynamics about precision, anticipation, keeping possibilities alive. But it’s really about itself, not anything in the broader human experience. (Which is completely fine!) How could we change that? Borrow from Train: playing field is a train car at the edge of the Warsaw Ghetto. Each line is a car full of people, will only leave if it’s full. Gameplay otherwise identical.

How do you play? Dutiful servant. Schindler: most fill rows, but leave gaps to trains don’t leave. Saboteur: stack up pieces as high and as quickly as possible.

New potential meanings. Not from the mechanics: from the interplay between mechanics and the game’s fiction.

Street Fighter isn’t about a battle between Ken and Ryu, it’s about a battle between two players. Then, he talked about the Shusai—Kitani match, chronicled by Kawabata in The Master of Go. It’s about a shift in Japanese ideals just before World War 2.

Go has very simple rules. Add in tournament rules: time limits, sealed moves.

120th move: Shusai makes move that sets up battle in middle of the board. Lots of questions for how to respond. Kitani thought for an hour and a half; sealed move.

Sealed move was a forcing move elsewhere. So upshot was that Kitani got an extra two days to think about how to respond in the middle of the board. Shusai felt Kitani had ruined the match. Kitani didn’t see anything wrong. Shusai ended up losing by 5 points, died a year later.

Go isn’t about competing world views of Japan, but this game was. Meaning is a synthesis. Meaning is rigorous. And meaning is instantial, determined by how a specific match is played.

1991: Soviet Union collapsed, Cuba lost its dominant trading partner. Average Cuban lost 20 pounds over the next four years. But agriculture responded by moving closer to consumer, worked out well.

Dynamism isn’t a feature: it is the fundamental core of how games mean.

• City of Wonder: Postmortem
• Humanities Unlocked: The Value of Liberal Arts for Your Game Design Program
• We Don’t Need No Stinkin’ Badges: How to Re-invent Reality Without Gamification
• Intuition vs Metrics: How Social Game Design Has Evolved
• Rapid-Fire Indies

10:00am–11:00am: “City of Wonder: Postmortem”, by Troy Whitlock and Scott Jon Siegel

Actually, only Scott spoke, presumably because Troy is no longer at Playdom. (He left a week or two before I did.) At any rate, I was glad to see a postmortem of this game, it was one of my favorite social games from last year.

The game‘s original pitch: expand your city state, discover technologies, battle with armies, from the dawn of history to the present. Take the Social City engine, add in more choice and player-versus-player combat.

Scott thought the original pitch was a crazy idea, had little interest in working with it. Social City was genre-defining, which meant that it had spawned a lot of competition. And Studio 24 (the Playdom studio that he was part of) had previous experience with market saturation: that’s a big reason why Fish Friends failed.

Also, the pitch looked like a niche game; it wasn’t clear it would get the same nice demographic that Social City got. So why do it?

Reason 1: PvP + isometric city builders. Both of those factors do a good job of leading to item purchases. The former affects game mechanics (combat), but doesn’t affect customization. The latter has opposite problem: only aesthetic. Maybe you can merge the virtues: give a stat boost plus expression?

Reason 2: The challenge of making “hardcore” features appeal to casual players, let people do what interests them.

Social City had a good core loop: money, population, happiness: need to work on all three, leading to virtuous cycle. City of Wonder kept the same base mechanics, except it gated new buildings by progress along the technology tree instead of strictly by experience.

Also, the research / technology tree led to long arcs, longer-term goals. Leads to diversity of city appearance. But traditional tech trees look like spaghetti maze: definitely didn’t want that. So they made it much less intertwined: even that, though was potentially too overwhelming for casual players. So they left the full tech tree as a depth on demand feature, but presented a few choices through the main view, with advisors giving specific recommendations. (And, as a bonus, the advisors give the game more personality.)

Also wanted to bring across point of progressing through time, e.g. by giving a parade when you reach the Bronze Age. But in early playtests, players thought it was a stone age game, which not all players were as interested in. So they addressed the sense of progression in the loading screen, in splash text, and in having each age’s buildings having a distinctive look.

Title: Social Civ was its working title. They tested various names; City of Wonder consistently won. Scott didn’t like it – e.g. no use of “wonder” within the game. But they went with it; his current theory is that people like it because of a song lyric.

Embassies: they wanted a neighbor mechanic, and wanted to do that in a way that’s not just a one-time thing, but instead has a concrete ongoing effect on your own city.

PvP: provides a second trio of attributes for buildings, cultural / economic / military. It’s hard to do well on all three, so people could specialize in one or two. The combat outcome (and what played into it) is hard to explain; they iterated a lot on that screen. Emphasized differences between wins and losses, and reinforced distinction between different types of expeditions.

Legends were most fun part of development: enjoyed coming up with quotes (hat tip to Steve Meretzky).

Game as a whole was his favorite social game development experience. Havin said that:

What went right:

• Casual focus, or democratization is a better term – the iPod is an example of what they’re going for, letting user find any song in at most three button presses. So they made main game features accessible with minimal clicks; other features are optional, scalable.
• Iteration. Everywhere: e.g. the placement of buildings/roads in starting layout turned out to make a big difference. Supported via continuous integration, and always having a stable build available. Scrubbed the game every day: errors in text, glitches, feel of an aspect of gameplay, …  Started as 3-hour meeting, got shorter as game progressed.
• Amazing team, split between Mountain View and India.

What went wrong:

• Legends. So appealing that management encouraged them to double down with legends as a trading card concept. Sounded good, but trading card aspects were added in last minute, so not enough iteration: badly balanced, badly explained. (Most successful ones were promoted during pinch points.) Ultimately not sure if feature did more harm or good.
• Embassies. Added somewhat late; main issue they didn’t deal with at launch was “Embassytown”, where your city is cluttered with embassies. Thought it would only affect a few users, but affected many, especially your most engaged users. Eventually solved via multi-embassy buildings.
• PvP. Unexpected side effects of choices players could make, sometimes made players unhappy. No reward in attacking higher-level players: you know you’ll lose, or even if you won’t, there’s not a big reward. So don’t get the excitement of working towards big wins.

The game is still a live service. They recently released the first colony, and there’s room for more. Colonies let them grow the game, even adding new features (e.g. naval expeditions in the water colony) without hurting the core gameplay in the main colony.

11:15am–11:45am: “Humanities Unlocked: The Value of Liberal Arts for Your Game Design Program”, by Mia Consalvo

First, her slides:

She started with a word on advising: “advising itself can be problematic”. At her first job, she received signals that it wasn’t important. At her second job, it was easy to fall into rhetoric like “you only need to take four of these five areas”. Now at MIT: students like math / technology, hard to get them to take humanities.

What is the worth of the humanities? College costs a lot; what will you do with an English major? Humanities programs are getting cut. She’ll present four case studies showing how humanities courses are valuable for game design.

1) Philosophy

Mentioned Miguel Sicart, and a Project Horseshoe white paper on ethical issues.

Ethical theories: virtue ethics (good habits of character, but with balance); utilitarianism (look at consequences of action: are they more favorable or unfavorable (to everyone); duty theory (have specific foundational principles of obligation: e.g. stealing is wrong).

When playing games with good/evil split, players generally take he good side in the first playthrough: it’s easier, more natural, how they were trained. (Even when trying to be bad, players accidentally did good when playing on autopilot.) Why, exactly? Is the underlying theory duty-based? Is it the rules: the good guy always wins? More content: evil in games often means selfish, so you don’t get to do side quests?

Discussion of Zevran in Dragon Age: Origins: she thought she’d been being a good manager, but Zevran turned, she killed him. Then in Awakenings, she had a similar issue; this time, though, it was a character that she’d gone out of her way to cultivate. Ultimately, though, they disagreed about something important, no amount of convincing worked. Which annoyed her at first, but she rather respected the designer’s choice once she’d thought about it more.

2) Foreign languages

Western otaku: lead to interest in culture, languages. Many people took organized courses; some learned on their own, though. And then learned about Japanese people, culture, not just about their favorite anime/games. Almost everybody either had one to Japan or had plans to, almost always in study abroad context, not standard tourist stuff. So: “the cosmopolitan western otaku”.

Can even lead to business: e.g. Carpe Fulgur, who brought Recettear to the U.S., and were quite successful in doing so. Fan interest can open up new, viable markets.

3) Classics

Talked about Sophocles project from the GAMBIT lab at MIT. They had to figure out how to allow player agency while being true to the tragic ending. 

In general: there are a lot of stories out there, but we retell the same ones over and over again in games. How can we tell other sorts of stories? Classics have great source material.

4) Literature

Talks about Edith Wharton: read great example of characterization. Wouldn’t want that much text in games, but very much want characters who are such individuals. Also talked about roles in society: so much games can learn from that, too. (Not least “social games”.) How do we function as groups, as people?

1:45pm–2:45pm: “We Don’t Need No Stinkin’ Badges: How to Re-invent Reality Without Gamification”, by Jane McGonigal

I rather liked this talk. Or at least with a caveat: I didn’t take too many notes because it was going by so fast and because her slides are on Slideshare, so part of the talk turned into my nap. (I’m essentially incapable of going to a conference without napping through parts of one talk a day.) But I really like her emphasis on the positive aspects of what it could mean to bring games to a broader context, and her using the term “gameful” to refer to those positive aspects (emphasizing the intrinsic benefits of games, as opposed to “gamification”, which is generally used more for the extrinsic reward aspects of games). “You don’t need a badge when you have real power.”

3:00pm–4:00pm: “Intuition vs Metrics: How Social Game Design Has Evolved”, by Laralyn McWilliams and Brenda Brathwaite

This was my favorite talk of GDC so far. I don’t think I’ll be able to give a good feel for that here, however; go to Brenda’s blog for the slides, but imagine that they’re delivered with even more character than in the slides.

But beyond that: it was just a super sensible talk: of course you want data when developing games, of course you need to develop and apply judgment to make best use of that data, of course there are minefields that you’ll encounter when navigating this. (Especially because of the culture clash of traditional game design with traditional web app design.) This is a message that still bears repeating over and over again, and we still need a great deal of compassion while figuring out how to move forward.

My notes are below, but I’m not sure there’s anything in them that you won’t get from the slides.

Collision of worlds: traditional game industry versus web apps. Could be great, or one side could consume the other, with bad results. Both worlds have a way of doing things, both think they are right.

Traditional game design: level 30. Social game: level 3. But social game success is undeniable. “Yay! Cake. Ooh! Money!” (Is the “real cake” that traditional game developers make even something that Facebook gamers even want to eat?) Brenda: to make a social game to me is harder than making a Wizardry game.

Both sides nervously hire people from the other side.

Game designers: “I just know it’s going to be fun.” Worked for Wizardry, but to people from the web space, it’s crazy not to ask users and try things out.

Traditional game design: jam shit in, rip shit out, until you find the fun. Clash with web space PMs: your idea of fun is nice, but I think X will be a better user experience, how do we really know? Any data?

MMO experience: sure, jam shit in, but start with shit that’s similar to what you’ve seen work in previous games. And shipping the game is just the start.

To traditional game designers, shipping an unfinished game is terrifying. It might be horrible; what’s worse, people might see a horrible it and love it! Intellectually, alpha testing makes sense; and maybe a couple of years ago you could have released quietly; these days, everybody will notice as soon as you launch.

“The business and Silicon Valley culture is the game.”

Numbers sometimes tell you what you already know. Even if not, though, they’re just symptoms. So: don’t leap immediately from numbers to solutions.

Creativity flourishes within constraints: metrics are one way of providing those constraints.

Don’t blindly follow metrics. Game design is the map and the plan; metrics is the weather report which may cause us to re-evaluate.

Success story one: accidentally released Ravenwood Fair with super easy numbers on various design parameters. To make an appropriate challenge, set numbers back; monetization plummeted. Turns out that players wanted a lot less challenge than Brenda expected; good thing they made that mistake and had metrics to help.

Success story two: Free Realms launched; play time was great, but players didn’t progress beyond level 1. Tried simple fixes, didn’t work. Eventually, observing players, found: camera was a problem, but more important, they were partying! Having a great time, they didn’t care about quests. Would have been hard to find root cause with metrics (according to Laralyn, at least), but very useful info going forward.

4:15pm–5:15pm: “Rapid-Fire Indies”, by ten speakers

Not much to say here: I’ve pretty much given up on trying to convey the experience of microtalks. A pretty good series of microtalks, though.

Chris Hecker: AAA Indie games: polished to perfection, clearly contains lots of love, highly anticipated before launch. First two obvious, talk about the latter.

Petri Purho: Didn’t say much, then played a music video.

Eddy Boxerman: Old devs: he’s turning 40. (Yay!)

David Hellman: Just pictures, but good ones.

Kyle Pulver: Game jams are awesome.

Chris DeLeon: Lots of 20-second bits, followed by Thoreau quotes

Andre Clark: How to be an Indie Punk: The Story of pOnd.

Markus Persson (Notch): Piracy. Favorite bit: the idea of a “lost sale” is the stupidest thing ever. Also: game development as a service. Maybe people who pirate this week will buy next week.

Scott Anderson: Using Technology for Gameplay Innovation. E.g. using shadow physics for gameplay. Inspirations: demo scene; creative coding; molecular gastronomy.

Anna Anthropy: The words we choose as labels define the limits of our discussion. With new tools, distribution methods, game development is available to anyone: “indie” needlessly carves out a group.