|January 7th, 2009|
SusanC has a comment on a Terra Nova thread in which she observes,
So the main criterion for being considered is that there is some kind of creative expression involved. I’m OK with that, although it opens the door for arguments about exactly how much creative input is needed to qualify. Text chat, instant messages, and blog postings (like this one) clearly can be used for creative expression: so maybe these are within the paper’s scope, provided that they are sufficiently creative.
– comment on Terra Nova: New Paper on UGC.
It is an interesting problem, actually. There is hardly a site these days of any sort on the Net that does not support some form of user-generated content. But by unspoken convention, we seem to not consider chat and other basic synchronous social interaction to be the same sort of user created content that uploaded models and textures are.
I think the reason is interesting and subtle, and marks out a distinction between “extending the possibility space” and, well, “not.” So here go 1700 words…
The ability to chat in real-time has been part and parcel of MUDs (and by extension virtual worlds of many stripes) since the very beginning. It was just one of many capabilities provided to the ordinary user of the system (e.g., a user without admin privileges of any sort). This pattern has remained — most virtual worlds do not make a user “earn” the ability to chat (though I have seen muds that did so, in order to prevent spamming by guests or recently banned users).
So you could engage in this form of undeniably creative expression right off the bat. What you couldn’t do was extend the world; that, you had to earn. You couldn’t just rewrite the server. You needed permission to do that. In essence, virtual worlds were born as authored objects; the chat that users engaged in was simply part of the authored environment.
A similar pattern was true in the early computer games. They were clearly authored objects. Even when users could contribute something, it was generally after there was a strong sense of authorship to the work. As we got to user-created content in videogames, we started using terms such as “modding” — from to modify (as opposed to “create”!) or “mapmaking” or “level design.” In pen and paper, where user-contributed content was absolutely fundamental to moment-to-moment play even in the rules, we still speak of “modules” and of “core rules.” And even in the (influential) world of genre fandom, we speak of “fanfic” as being of a different order than the original work. The framework is clearly something authored, and extensions, new creations, and so on, are accretions on that basic framework.
In virtual world terms, the commonest architecture, going back a long ways, has two data repositories. One may be conveniently though perhaps inaccurately termed the static database — it is the state of the designed environment, the source of the template from which the running world is created. The other is the runtime or persistence database, which tracks data expected to change. (Handy diagram and explanation of this here, though really, you should read everything in Chapter Six).
When we speak of UGC or UCC these days, we have many sorts of systems to choose from. We have frameworks which provide a nearly 100% “user created” experience, such as IRC, that we simply don’t think to use that term with. We have systems like Flickr, which are designed as repositories of user creations.We have blogging, and Facebook, and Wikipedia. Yet we do think of say, my posts versus your comments as being from different sorts of “user,” just as Flickr doesn’t let users rewrite the copy on its websites.
And we have virtual worlds, now dating back to around 1988-89, The Playground, and TinyMUD, which do not gate the addition of new framework elements, but instead permit the user to extend the system via the simple expedient of not having a static source database, but instead putting everything in the runtime database.
What is the framework? Well, it’s systemic aspects of the simulation, of course. It could be thought of as content that appears to originate with the server, the system, the authored object, rather than from another user, at least on first blush. It may seem an odd distinction, in these days when the line is so blurred, but another way to think of it is that it is any runtime or static database-sourced element in the environment, as opposed to ephemera.
This line used to be much clearer than it is now, and thus this whole post may seem to be splitting hairs. But it seems to me that the common usage of the term “user created content” is primarily driven by past culture. In mud and then MMORPG culture, the technical architectures and administrative practices have drawn a line based primarily on persistence of the creation and how it is displayed to the user — and I am not entirely sure that a similar bias doesn’t exist for many other applications and systems as well. And thus, we may think of a user’s textual description of themselves in a mud as maybe being user-created content, and certainly of their carefully laid out plot of land in Second Life as being UGC, but not their chat or even their forum posts.
That said, it does close us off from intriguing concepts such as looking at videogame playthroughs as being a form of content or creative expression, or post-facto storytelling as a form of authored narrative.
We also wrestle, these days, with the question of atomicity. There’s an unspoken bias, I think, towards considering highly atomic creation (say, new code, new art, new text) as being somehow “more user created” than less atomic creation (say, rearranging art to lay out your Habbo Hotel room, collaging, attaching existing behaviors to objects, or making a game with Mockingbird. In today’s remix culture, this is an important discussion to be had — after all, as I have observed before,
The number one use of user-created content in virtual spaces is the screenshot. And that is user content creation. It is shared more widely, distributed, commented on, annotated. That’s actually where the action is, things that have a far lower barrier to entry. The interesting areas of user-content creation .are in mashup and remix, like they are everywhere else, screenshot comments, WoW dance videos, dancing itself, stuff like that. That’s where a lot of the action is, because that’s where the barrier is low.
Part of the reason may be that less atomic creation is creativity bounded to some large degree by the parts provided. Put another way, there’s a sameness to everything made with Legos, because the blocks enable a grosser level of creation and also hinder the finer level. As a result, we eagerly pass around stuff that pushes at the boundaries (like say, Tetris clones made in LittleBigPlanet), and we also chunk up and dimiss stuff that is clearly assembled from pieces that we are long familiar with — it’s a similar issue to what we run into with procedural content, basically pattern recognition rendering things boring.
It’s a mistake to consider less atomic creation to somehow be less important or less empowering than more atomic creation. But there is also something to the notion that there is a phase transition of sorts that happens when users are allowed to make highly specific changes to the framework. When users can make Lego blocks, you end up with a very different set of Legos over time.
It may be that what we need, as we think about the boundaries of user created content, is more precise terms. It isn’t hard to think of a systemic hierarchy wherein we speak of services classified into tiers, such as
- user expression permitted (chat!)
- user-assembled content (arrange Legos all you want!)
- user-customized content (paint the blocks! — parametric changes)
- user-created content (make new blocks! Still within the framework)
- user-modifiable framework (add a Lincoln Logs system!)
In fact — it’s quite possible for a system to provide the high end but not the low end, or skip one in the middle. It is also possible to attempt to create an ecology whereby higher tiers are in service to lower tiers.
All of this harkens back to Marc Andreessen’s wonderful essay on types of platform. The word “platform” is also one that has gotten both loosey-goosey (everything is a platform these days) and in some sense, tarred with negativity, because in a stricter sense it sounds technoelitist (“it means something you can program!”). In Marc’s terms, you’d have to be at least at tier 4 to be considered a platform. And he breaks even tier five into three sorts of platforms (access APIs, plugin APIs, and runtime environments).
Of course, there’s a point there at which you start saying “are these folks users anymore?” Perhaps they are in a developer program, for example. Are Facebook apps UGC? If not, why not?
In the end, the thing that seems clear to me is that the lines between user and developer are blurring, and that this may in fact be a historical imperative. Consider a world where the framework was built by hobbyists in the first place, and is open to modification, and is a runtime environment, and allows non-admin users to customize and create Lego blocks… if this happens to be common enterprise software, is it UGC? Because I am describing the LAMP stack — Linux, Apache, Perl/Python, MySQL — that today powers much of the Web.
Marc observes that the power of what he calls Level 3 platforms lies in the new sorts of applications that they enable — uses that you basically did not foresee that are made possible by the lowered costs and decreased complexity. The way the Web works enabled LAMP which enabled blogging, which enabled all sorts of communities, and an awful lot of classic UGC, and an even larger amount of commentary, mashup, and annotation, and overall some rather splendiferous creativity and plenty of unforeseen things. And at every tier there were users, just users of a different layer of the onion. In some sense, I by writing here am both developer and user creating content, and every Russian nested doll can lay claim to participating in UGC.