blog.gkaindl.com

Save-Games for Non-Gamers

Yesterday, I’ve written about save-games and their nature of encouraging explorative behavior as well as taking pressure off the player’s shoulders.

But what about expanding the (well-known) metaphor of save-games to other applications as well. After all, trial-and-error or explorative practices are not limited to games, they are an inherent part of many workflows as well.

Usually, if you are working on a document and want to save it in a particular state to possibly come back to it later, you’ll need to save it as a copy. This is based on the file-system metaphor, where each item is represented as its own file. A save-game, however, is not perceived a file, but as a snapshot of the game (state), i.e. the metaphor is a state.

Currently, the “state” metaphor is rarely ever applied to work documents (Apple’s TimeMachine in the upcoming Leopard is going in this direction, but the user does not consciously take snapshots, the system does it in the background). One of the few applications I know of that have such a feature is CSSEdit, which allows you to specify “Milestone” versions of a document that function like snapshots.

Generally, the demand for such a snapshot feature is clearly there. After all, version control systems such as Subversion and CVS do exactly that. While their main aim is to facilitate group collaboration on textual content (most often program source code), they are used in single-person projects as well, just for the ability to take snapshots of the work-in-progress regularly, rolling back to them at will, comparing them with each other and similar tasks. As such, an SVN or CVS repository can be seen as an archive of snapshots, much like the archive of save-games, taken at different points during the game progress.

Such a feature could be incredibly easy to implement, since we can simply have a look at how the version control systems do it: They don’t save complete versions, they save differences. For example, if I’m working on a text document and take a snapshot of the current contents, then change a single paragraph and take a snapshot again, only this paragraph would be saved again. Remember, this is not about backups, it’s about the possibility to restore a previous state. If I wanted to roll back multiple steps, the changes would be applied successively in inverse chronological order. From a programmatic point of view, this is very simple, especially in Cocoa, where the changes could be easily extracted by observing some keys.

Much like what’s happening with games that employ the ability to save at any time, such a feature in a document-based application would most likely lead to the user feeling more relaxed about experimenting with various aspects of the program’s workflow. Additionally, all the other uses of a version control system (such as comparing different snapshots between each other) could be cheaply implemented, too. I think this would be incredibly useful to a whole lot of people.

Additionally, think of this possibility: Wouldn’t this feature be cool to post little tutorials, too? Think of a Photoshop tutorial that comes with a PSD file where you could iteratively go through all the stages of producing the given content: The first snapshot could contain the blank document, snapshot 2 illustrates the first work steps, etc… If accompanied by a text or video tutorial, this could enable the student to try out the steps themselves, without having to set up stuff they are already familiar with: Just choose the step you want to practice, and there you go!

Thusly, I think the idea of save-games could be worth for application developers to have a look at, too. After all, it’s a rather simple thing to implement, but it could potentially be very well received.