Media Theory for the 21st Century

January 22, 2008

Week 3 Intervention: The End of Protected Mode?

Filed under: Discussion — P.J. @ 12:16 am

For consideration at seminar tomorrow…

While reading Kittler’s above-mentioned essay, I immediately recalled a story from Gizmodo not too long ago, which directs to this recent news story from Poland.

Given Kittler’s assertion that computer makers develop a highly-structured and bureaucratically-toned “protective mode” specifically to keep the end user from directly communicating with the hardware that’s doing all the work, I’m interested in knowing whether this event – not to mention other Web 2.0 phenomena like the blogosphere and social networking – heralds a definitive complication of Kittler’s argument, or rather stands to become the exception that proves his “rule.”

Advertisements

1 Comment »

  1. Perhaps this does mean that accessibility is going up — I think open-source development is in some ways a contradiction to the idea of protected mode, but I think we see a kind of rolling de-protection; this is that hardware considered obsolete and archaic is opened up, and the more modern, marketable tech is protected.

    What has become more clear is a complication of Kittler’s argument: though user-friendliness and openness are generally inversely proportional, as user-friendliness goes down to the level of software development, openness increases. Now most Comp Sci students are taught in virtual-machine languages like Java or .NET languages, which cannot access the lowest levels of computer hardware, and do not even permit memory management. However, as the lowest levels get more obfuscated by virtual machines, code becomes more accessible, both because we can write and learn it, and because we can see it.

    Hiding low-level operations actually allows novice programmers to write more stable and easier-to-use application, and opens up different systems. It used to be that software development required paying someone money for a compiler. It used to be that you had to write Nintendo games in NES assembler, then send the code off to Nintendo, Inc. to be put on the cartridges – and they had a strict “no blood” policy.

    Now, coding is simpler. The development of Java was one step toward this — allowing coders to write without actually having to worry about the specificities of platform and hardware (or a good many of them, at least) but a more interesting and important one, I think, is the development of Microsoft .NET. This is a suite of free, simple(r) programming languages that can run on any Windows machine and the XBox 360. .NET makes it easier for more novice programmers, like myself, to write programs, and for systems that used to be closed to anyone but those who had secured official licenses from the companies.

    Also, because the code of .NET, Java, and Flash is simpler, and because it runs on a virtual machine, it’s actually easier to return the compiled applications to their original source code, to see what’s going on under the hood. I think as we move further into protected mode, software becomes more transparent. We can’t really see what’s going on under the hood at the level of voltage differences, true, but we can see the source text. In fact, Kittler’s DOS-based WordPerfect was completely opaque, because decompiling it back to source would have been impossible, and it was protected, anyway. NeoOffice, Java-based and heavily dependent on Mac GUI frameworks, can be returned to source.

    This is not to say that we can see everything — we still may not be able to view the source code of the .NET virtual machine (though Java is now open) — but that we are being given more freedom on our systems. In the old days, access to the machine was restricted to large corporations who could afford not only the machines themselves but the techs who could devote the time to explaining them to the less technical users. It seems to me that we can never have a truly “open” system; a more open system requires more technical knowledge to understand, and a simpler system requires hiding at least a few operations from the user.

    Comment by David Shepard — January 22, 2008 @ 9:31 pm | Reply


RSS feed for comments on this post. TrackBack URI

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Create a free website or blog at WordPress.com.

%d bloggers like this: