blogrium

A while back I discovered the MDA framework for game design, which, like a Will Wright presentation, struck a chord. As a recap, it’s a conceptual framework that breaks games down into mechanics, dynamics, and aesthetics as a much needed formal vocabulary for game design. In the context of games, the components of MDA are explained as:

• Mechanics - the underlying rules and structure of a game created by the game designer
• Dynamics - the runtime behavior of the game with interaction from the player based on the mechanics
• Aesthetics - the emotional response of the player from experiencing and interacting with the game

These components form a directional stack that to the designer are experienced from mechanics to aesthetics and to a player from aesthetics to mechanics. Together they form a system that describes the interactive experience of games, where the mechanics laid out by the designer unfold through the dynamics of simulation and create the aesthetic experience of the player.

Aesthetics in this framework is a big topic of its own, as described in the original paper on MDA by Robin Hunicke, Marc LeBlanc, and Robert Zubek. This guy here seems to have some great commentary that elaborates even more on the aesthetic component that’s also very much worth reading as it relates to experience design.

However, my interest is mostly in dynamics (the home of emergence) and in the framework as a whole, which I’ve found, like many things, has relevance outside of games.

It didn’t take long for me to make the connection of MDA with software in general. The writing of mechanics in the form of code, the runtime dynamics of that code being executed and interacted with by the user, and the end user experience described through aesthetics is a great way to look at any software.

The reason I’m writing about this now is that I just found an old presentation by Marc LeBlanc, the one who seems most responsible for MDA, that actually explains and introduces MDA with this connection. He jumps into things by saying things like:

Games are state machines

All games are computer games

Game design is programming

It should be obvious that digital games, although being software, are completely different from all other software. Where most application software are tools and represent a certain amount of new empowering technology or new means to an end, games are for the most part not technology in the sense that they are more of an end than a means to an end. LeBlanc describes this as games serving an emotional purpose, not a pragmatic one.

Although it differs from my interpretation of the aesthetic component for software, LeBlanc introduces MDA in this presentation as their concrete components in both software and games. In software you have a stack that looks like this:

Code -> Process -> Requirements

You write code that executes through process to achieve the requirements. Where of course the requirements represent the function the software is supposed to play or the use cases it satisfies as a tool. He compares this to games which has a stack that parallels software like this:

Rules -> Game “Session” -> “Fun”

And then he unifies these as mechanics, dynamics and aesthetics.

Mechanics -> Dynamics -> Aesthetics

So it’s very fascinating that he came up with this game design framework with an awareness of its relation to not just games but traditional software. The real neat part is that if MDA is a model that can be applied to all software, and software is just a medium for virtualized dynamic systems, then MDA can probably be applied to any dynamic system. MDA isn’t just a framework for games, it’s a framework for all systems.

Okay, so on to emergence.

One way to describe the difference between games and software is that software deliberately avoids emergent behavior, where games embrace it. With software being a tool, you can’t have it behave unexpectedly. But with games, unexpected emergent behavior provides a richer experience.

The thing about emergence I only recently realized is that it requires a progression of time. Therefore emergence is the realm of dynamics. And it’s interesting that there seems to be a lot of interest in aesthetics and mechanics, but not so much in dynamics. But there is interest in emergence.

No surprise, Will Wright, one of the masters of emergence, did an entire talk about dynamics called Dynamics for Designers. In fact, it also doubled as a talk about systems, but you’d have to know about systems to see it.

It turns out that dynamics and emergence are a central theme in general systems theory. In systems, the dynamic interaction of parts is more important than the parts themselves, and this interaction results in a whole greater than the sum of the parts. That’s emergence.

There’s two views of emergence. Weak emergence and strong emergence. Weak emergence would describe new emergent properties of a system as reducible and traceable back to the system’s constituent parts. Strong emergence would describe emergent properties as irreducible and untraceable to its parts, and that the system whole supervenes on its components. Mark Bedau described strong emergence as “uncomfortably like magic” because it seems to involve getting something from nothing.

I think about emergence as dynamic runtime behavior that’s not obvious by observing the mechanics that drive them. This would suggest that emergent properties are subjective rather than objective, and that emergent properties just represent what we don’t know about a given set of mechanics.

To me, it makes sense that we can have both views of emergence coincide. Emergence that we can explain is weak emergence, and emergence that we can’t explain (yet) is strong emergence. It’s less a matter of perspective than about categorizing emergent phenomena as reducible or not.

The great thing about emergence is that it usually involves simple parts interacting in a special way to create a greater outcome. I think the appeal of emergence in design is that you can get more bang for your buck. That’s how we got generative systems.

A generative systems is actually something very new and I’m pretty sure was coined by Will Wright after an audience vote on what to call it. Now, since I haven’t had a chance to talk to Will Wright yet, I can only conclude that a generative system is one that takes advantage of emergence or where emergence is a core function of the system.

It seems possible that generative systems could be a new paradigm for studying and exploiting the powers of emergence. Today we have design patterns in software for mechanics that solve structural and organizational problems. We have design patterns for dynamics that solve runtime and process problems, only they’re called algorithms. However, algorithms solve computational problems for the purpose of creating expected behavior. Will generative systems yield similar design patterns for emergence?

This entry was posted on Tuesday, March 27th, 2007 at 4:34 pm and is filed under Design, Games, Systems Theory. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.