Perhaps in distinction to Crawford, I’m not introducing this playback-computation idea only to say that playback is bad. My comments have tended to snub playback a bit, but I don’t think games get monotonically better the less playback they have. Dragon’s Lair is an interesting game, and was innovative because of how it used more playback than other games of that time.

Even the recipe program with fancy rendering has more potential to render different scenes (perhaps untapped) coded into it; whether this is an interesting capability or whether this power is used is another matter. The player’s actions (considered on the operator-machine axis) can be “thrown away” or can cause no significant, high-level change, as with additional computation, but it’s still useful to look at both axes.

The example I’m using comes from Edsgar W. Dijkstra, specifically EWD277. The only thing Dijkstra says about the program that prints a stored list of 1000 prime numbers is that it is an “obvious version of the program” and “We shall not pursue this version, as it would imply that the programmer hardly needed the machine at all.”

One can find two programs, one using playback and one using computation, to do anything that can be computed. The differing time/space requirements may not even be perceptible; there may be no perceptible difference at all in terms of output or runs. But a video game or other program that does almost nothing but playback is one in which the programmer hardly needs the machine at all. It’s not just a matter of the author’s conception of the program. With such a program, the function implemented cannot be general and is less likely to be interesting.

To relate this to one of Galloway’s axes, operator-machine: If we take a particular ten minutes of play of Grand Theft Auto: Vice City, capture video of it, and then play back the video, our video does exactly the same thing that the video game did in terms of output. We could say that having a video vs. having the game (manipulated in a certain way) is just a matter of time/space tradeoff. But that misses the point that we have an interactive computer program in one case – capable of dealing with input and doing something else as well as what it did – and a video that can do only one thing in the other case.

Dragon’s Lair is interactive, but consists of the playback of clips of video; characterizing it along the operator-machine axis as well as the playback-computation one helps to differentiate it from, say, a turn-based strategy game like Advance Wars in which there are (similarly) limited points of control, but what happens is being generated at least in part rather than being played back.

I’m quite interested in understanding new media at the level of computer systems and organization as well, but what I’m trying to get at here is not really at this level. It also isn’t just a question of how the author thought about things, although that is important, too. Instead, it’s meant to be an aspect of how the program functions, as Galloway’s two axes are.

What I’m saying is that I think a recipe program, even if it used fancy rendering to achieve a high crunch per bit ratio, would still make sense to place “low” on the process intensity scale. We just need to stop thinking of process intensity as “crunch per bit” and instead as something like “crunch per behavior” or “crunch per decision”.

I mean, any process on a computer ends up being a function, and mathematically a table (vector) of values is just a function too. (albeit with a finite domain, though this could easily represent a finite partitioning of an infinite domain) I can make a table lookup very complicated and look like a function, or I can make a function look very much like a table lookup. I can take a function which doesn’t use tables at all and pre-compute a common case table to speed up execution. Regardless, I’m left with, mathematically, the same function. It’s just written differently.

Maybe, is the point is to talk about how the author conceives of and writes the process rather than what the actual process going on is?

ps. sorry if I’m being confrontational. I’m just trying to get a handle on the concept

… I really do like the blog. =)

But none of this really matters when it comes to process intensity. I like considering instruction set architectures as much as the next girl, but process intensity isn’t directly about CPU utilization or things that are more detailed. Printing 1000 prime numbers from a file is less process intensive than is actually computing those numbers; It’s useful to characterize creative computing along this dimension to understand what is going on in it.

“The difference between process and data is profound. Process is abstract where data is tangible. Data is direct, where process is indirect. The difference between data and process is the difference between numbers and equations, between facts and principles, between events and forces, between knowledge and ideas.

Processing data is the very essence of what a computer does.”

The key insight of the Von Neumann Machine (ie. every modern computer) is the “stored program” or that process is data; there is no fundamental difference between the two. Crawford also distinguishes between just moving data and processing, but at ISA level these are really both just instructions. What appears to be computation at one level of abstraction may actually involve moving quite a bit of data shunting, and likewise a request to move data can often be abstracted such that nothing is actually moved in some cases.

It seems to me that if process intensity is to be a useful concept, process and data need to be expressed such that they don’t appeal to the lower level, and highly abstract world of arithmetical operations and primitive data types.

If some programs are doing “wasted” computation (computing something and throwing the results away), or have a lot of overhead because all programs that run on a particular platform have such overhead, they might look more process intensive than they are. So you can remove the wasted and baseline computation before figuring out where they lie along this axis, and the “crunch per bit” tells you what useful computation is happening.

Distinguishing diegetic and extradiegetic texts seems like a harder problem in many cases, but I think it’s similarly useful to consider.

Of course, I haven’t read everything he’s written. Has he expanded on the concept somewhere and dealt with this? I think the important issue is the intensity of the processes that determine the system behavior, but then maybe we need a longer term — like “behavioral process intensity.”

It sounds to me like the dimension of “computation vs. playback” is meant to express (somewhat as Gilbert suggests above) the amount of potential computational variability. It may take some computation to decompress some FMV and shove it on screen, but there’s no potential for variability there. On the other hand, AI-driven NPC behavior has much potential for variability.

Of course, this still leaves us with things like procedural textures. They have potential for variation (just tweak the parameters) but usually this potential can’t be realized via player actions. I’m guessing this puts them somewhere in the middle of the computation/playback axis, but I’d be curious to hear Nick’s thoughts on this…

In your comment for essay 1, you suggest the addition of a third dimension, computation vs. playback. Being very tech nerdy about it, there’s quite a bit of computation involved in playback, and there are many things that might be seen as playback, but are actually done with quite a bit of computation, such as (for a somewhat trivial example) procedural texture generation. We might classify this as non-diegetic, computational, and machine controlled, but we would also classify tactical behavior in Counterstrike bots in the same way. The problem is that from the perspective of the average player these are different; the procedural textures are just being played back. Maybe it would be better to clarify computation as being context sensitive, by which I mean the computer is reacting to whatever has been classified as external stimuli. (ie. other computer agents, the physics, players, etc.)