Scholars and programmers are two groups that know hardly anything about each other, and yet the world needs them to come together, quickly.  Nothing less than the future of art and the existence of literature hangs in the balance, which I’ve tried to make clear to fellow programmers in the past.  Today, I want to address fellow scholars and give five critical reasons why the other side needs us and why we need them.

—

UPDATE: One of my readers pointed out that the term “scholar” is ambiguous.  For this article, I’ve used scholar to refer to humanities scholars in general.

Talking with programmers

I had written an article a while ago on OSNews (“The Death of the Computeral Craftsman”, 4/7/2010) lamenting the disappearance of a certain kind of aesthetic impulse in computers that I called “computeral craftsmanship”.  My fatal flaw was to explain this term on the second page:

Those who write in raw static HTML, on the other hand, can manipulate formatting to say what they mean with much greater control…I could replicate the same effects on my WordPress blog by editing the theme and its CSS, but it would be a separate act from writing the content and not a representation of my thoughts and emotions during the moment of creating the web page. This is the reason why an old Geocities page used to look so hideous, because its formatting was the impulsive expression ofthe author in situ; that is the kind of unity, between content and format through a continuous moment of expression, that Web has lost.

Clearly, almost no one got that far since I was instantly barraged by OSNews readers who, not understanding what I meant by “craftsmanship”, were furious that I would dare insult their career paths and honor by claiming that programmers are not “craftsmen” (i.e., people who do a good job and take pride in their work).  I particularly enjoyed comments to the effect of “clearly you have never done any professional programming” (I have), “I stopped reading after this: ______” (then why did you bother in the first place?), or “Actually, the first X wasn’t Y but rather Z, you should know this before you decide to write an article” (this is the sort of pedantry that often makes grade school miserable).

One reaction might be to dismiss OSNews’s audience with a stereotype, as anti-English majors completely incapable of understanding a thesis, which is indeed the exact attitude that one of my friends who works as a system administrator had.  Yet if anything, the fact that almost no one had gotten through to the end underscores the case that I’ve made on this blog, that we need to move past the page metaphor and discover authentically computeral methods of communication.

Beyond hermeneutics, however, there is a greater lesson: scholars and programmers both have a long way to go before they can start talking to each other on the same level.  My real purpose in writing that article was to start a conversation between these two sides by telling the engineers, “Hey, we need to start thinking less about gigaflops and more about Gilgamesh”, and the reaction was highly negative at first.  After I hashed out the meaning of some of my main points in the comments section, however, I began several positive and constructive discussions with my readers about everything from their emotions while programming to connections between Model-View-Controller-based applications and the dissemination of knowledge in the medieval West through the church.  The problem was that it took much effort to get to the point where we had enough of a mutual understanding to communicate.

Five points for scholars

So then why not start with the scholars?  Because as reactionary as programmers might be, humanities scholars are woefully unprepared for twenty first-century technology.  It’s difficult to relate Model-View-Controller schemas to someone who doesn’t understand database administration; put another way, while it’s difficult to explain why Canterbury Tales is great literature to someone who spends all day reading COBOL, it’s impossible to show why C++ is not art to someone who only knows Chaucer.

The truth is that both sides need to come closer to each other, and they need to do it quickly.  I’ve tried to make this clear to fellow programmers in the past, and today I want to address fellow scholars and give five critical reasons why the other side needs us and why we need them:

1. Computers are replacing literature. The fundamental premise of this blog, which I’ve harped on ad nauseum and which I’ll repeat here yet again, has been that the time that people used to spend reading books is now spent in front of computers, but that artistically, emotionally, and spiritually, computers lack something that books have.  That something has been at the core of Western civilization for hundreds of years, and we can already begin to feel the ill effects as it withers away: social alienation, a sense of emptiness, and above all loneliness.  The answer isn’t to back pedal into rotogravures and Gainsboroughian oil landscapes, but rather to take what we know about the magic of art and breath life into the new media, which demands people who still study art.  Otherwise, we can watch YouTube take over film and pretend that Twitter novels can replace the real thing.
2. Paper is a dead letter. Paper will never disappear, just as Socrates’s prediction that writing would completely supplant memory never came to pass, but like Socrates we are making the same fundamental error in assuming that new technology is 100% a natural extension from the old way of doing things.  For the stonemason, this meant that writing was a dangerous pharmakon to be treated with suspicion, whereas for us we think that we can pay lip service to computers by “digitizing texts” or using “online learning platforms”, thus establishing our credentials as progressive technocrats.  We need to do more, for our own sake.  The future of humanity will be written in light, literally, so if we don’t learn assembly programming or how TTL logic circuits work or at the very least Logo, then the very source material that defines our function, way of life, and careers will be totally alien.  Historians in fifty years who don’t understand memory management will be like chronologists before philology or archaeology, and Alexander von Humboldt will have to make room for Isidore of Seville.
3. We need more than just the imperative mood. There is a critical problem with computers that no one has pointed out yet, which is that every programming “language” is nothing more than a set of instructions.  In other words, the languages we are immersing ourselves in are completely in the imperative mood; there is no indicative or subjunctive, nor is there optative, jussive, potential, or room for any other modality.  How can there be art or literature when everything is a command?  Case in point, one of the most popular tools for creating software today, Microsoft Visual Studio, calls each program a “solution“.  A solution to what, the soul’s troubles?  Another example, a lot of people claim that video games are a new form of art, an argument that Roger Ebert thrashed eloquently since art is not “winnable”.  Yes, we might “play” with the text, but when have you ever gone into a museum and said “Booya, Rembrandt!  Take that, Picasso!  I always knew you were a punk!”?  If there’s anything that scholars are good for, it’s to make a straightforward issue seem so complicated that even the question slips away, which is the essence of our Sisyphus-like existence, only scholars bring it to a textual level where we can all enjoy humanity’s fist fight with itself.  Computing needs that kind of thinking if we’re going to cross the boundary into artistic expression.
4. We’re the only ones left who can read 300 pages at a time. After you run for three miles and hit the runner’s high, the world becomes a completely different place than what you had known before, just as a book read at 30 pages/hour will inevitably be different than the same book read at 80 pages/hour though the pages remain the same.  Similarly, the fragmentation of content due to digital technology has changed our perception of that content so much that it’s effectively changed the content itself.  (For one thing, we’ve begun referring to it as “content”, as if we were trading pork belly futures.)  Maybe that’s not a bad thing (doubtful), but there’s no way to compare the two unless we have people who understand both ways of thinking, fragmented and continuous, both clicking pixels and turning pages–and I don’t mean Clive Cussler.
5. Untold worlds already await. In case you think that everything I’ve proposed is for some Grossforschung project of the future, I want to point out that incredible stories and worlds are unfolding online right now despite the Internet’s pallor.  I’ve already discussed an incredible epistolary mini-”novel” between two branches of a powerful Syrian family unwittingly written in the backpages of Wikipedia.  There are examples, like the Neen movement, which have achieved some success creating moving new art based on computers (Miltos Manetas, a Neen leader, has even had some works exhibited at the Saatchi Gallery), albeit perhaps not completely computeral in the sense that I’ve talked about.  I read a thread at the PostSecret Community forums just yesterday where members decided to try sum up as much empirically-learned wisdom as they could (in case you are unfamiliar with PostSecret, click here).  Yes, they lacked the method of Aristotle and the set up of Richard Ford a la The Sportswriter, but the seed is the same kernel that sprouted speculative Greek philosophy.  Scholars can and should start talking about these things.

Nothing less than the future of art and the existence of literature hangs in the balance.

AMD’s Phenom II X6 has just been released, bringing six-core processing power within reach of students and others without thousands of dollars to spend on Intel’s Core i7 9xx series.  But how well does the X6 do with multithreaded open source development?  This short review looks into Linux development using GCC and make with AMD’s new processor.

—

Professional tools for (pseudo-)professional developers: The AMD Phenom II X6

Lately this blog has been dead, but only because I’ve delved deep into programming and the creation of a new Linux distribution based, in true WDR? fashion, on aesthetic principles that I’ve gained through my historical and philosophical studies.  However, one thing that was holding me back was my lack of a powerful development machine.  It’s incredible to think that for the past year I’ve done paid development on a netbook whose wiring is so flimsy that the video card can be fixed (or broken) by repeatedly dropping the machine from a height of two feet.  The time was right to invest in a desktop machine, especially now that I’ll be working for AbiWord in Google’s Summer of Code 2010 competition implementing non-linear page flows.

Enter the Phenom II X6, AMD’s latest and greatest CPU.  My friend who actually works in IT and I had agreed until just a couple of days ago that the Intel Core i5 750 would be the most cost effective option, but once the X6 was released its six cores won me over.  Numerous reviews have already shown that under non-multithreaded loads, AMD’s new processor is a loser, but as soon as the threads can utilize all six or even four cores, AMD trounces the competition.  As anyone who does Linux development knows, going multithreaded is usually as simple as typing “make -jN”, where N is the number of parallel jobs that you want to execute while building your app (normally N = number of cores/processors + 1).  At $200/$300 per processor, that would make the X6 a bargain-basement priced high-power workstation (Intel’s current six-core offering, the Core i7 9xx series, is actually faster than the X6 but also costs +$1000, out of the reach of mortals and students like myself).

Specs

Thus, I headed to MicroCenter and dropped ~$730 (including tax) buying parts to build a Phenom II X6-based system.  My final system consists of:

• CPU: AMD Phenom II X6 1090T Black Edition ($300)
• Motherboard: Gigabyte GA-880GM-UD2H, 880G chipset, mATX form factor ($50, after CPU bundle discount)
• Power supply: Enermax Tomahawk 500W ($50)
• CPU cooler: Zalman CNPS7500-Cu with blue LED, all copper radial heatsink ($40)
• Case: Cooler Master Elite 341, mATX mid-tower ($30)
• Memory: Kingston HyperX 4GB DDR3-1600 ($130)
• Video: AMD Radeon HD4250 (integrated, included with the motherboard)
• Hard drive: Western Digital Caviar Blue WD5000AAKS 500 GB 7,200 RPM SATA ($50)
• CD/DVD: Some random Toshiba dual layer Lightscribe DVD+/- RW ($35)
• Wireless: Crappy 802.11B/G card using Realtek 8139 chipset ($15)
• OS: Ubuntu 10.04 “Lucid Lynx” AMD64 edition (free and libre, though following the window button debacle perhaps not quite so free as in free speech)
• Video drivers: AMD’s proprietary fglrx XOrg drivers, v. 8.723.1, downloaded from Ubuntu
  

Yes, I did go ahead and splurge on some of the components.  Cheaper RAM, a cheaper power supply, the stock CPU cooler, and perhaps even a less expensive case could have been found.  In all, I could have probably shaved about $100 off without degrading performance, but since I value longevity and quality in my components I decided to spend extra.  There’s also a Phenom II X6 1055T model that has slower core speeds and that costs $100 less which may interest some readers.  I will probably try overclocking a little, especially since the 1090T is a Black Edition part and has an unlocked clock multiplier, but as the benchmark results below show there really isn’t any need.

Benchmarks (compiling)

As I’ve mentioned, this is supposed to be a development system to help me with my GSoC and Linux distribution work, so I thought that I’d run some compiles to see how fast they would finish.  For all these compiles, I have Firefox with 10 tabs running as I’m typing into Gchat and this WordPress blog, which represents a realistic compile environment for me.

First, my compiler’s information:

ersin@istanbul:~$ gcc -v
Using built-in specs.
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 4.4.3-4ubuntu5' \
  --with-bugurl=file:///usr/share/doc/gcc-4.4/README.Bugs --enable-languages=c,c++,fortran,objc,obj-c++ \
  --prefix=/usr --enable-shared --enable-multiarch --enable-linker-build-id --with-system-zlib \
  --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix \
  --with-gxx-include-dir=/usr/include/c++/4.4 --program-suffix=-4.4 --enable-nls \
  --enable-clocale=gnu --enable-libstdcxx-debug --enable-plugin --enable-objc-gc --disable-werror \
  --with-arch-32=i486 --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu \
  --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5)
ersin@istanbul:~$

Next, the actual tests:

AbiWord (using SVN r28860 from trunk after having run ./autogen.sh; configured with default settings, only plugins were opendocument and msword; no ccache):

ersin@istanbul:~/abiword$ time make -j7
...
real    1m45.630s
user    6m33.760s
sys    0m50.130s
ersin@istanbul:~/abiword$

Blazingly fast, I’d say!  My single-core Athlon 64 L110 netbook takes 30-45 minutes to do the same compile.

buildroot toolchain (2010.02 after having configured with make menuconfig and downloaded sources with make source; no target packages selected, only the toolchain with all compilers set to be built, including target utils and full GCC suite — gcc, g++, gcj, gcc-objc, and gfortran; 7 parallel jobs selected through make menuconfig; neither gdb nor tests built; no ccache):

ersin@istanbul:~/vorpo/build/buildroot-2010.02$ time make
...
real    19m15.274s
user    42m33.760s
sys    11m39.160s
ersin@istanbul:~/vorpo/build/buildroot-2010.02$

This is perhaps the more impressive of the two benchmarks.  An entire toolchain in under 20 minutes. In a $730 mATX system that I put together in my kitchen in an hour.  Ponder that for a second.  This same compile easily takes me 3+ hours on my netbook.  Throughout this compile, I checked up on my computer’s memory usage with GNOME’s System Monitor, and at no time did it exceed 1.5 GB memory, which includes the desktop and all the rest of the system.  CPU utilization on all six cores was 100% while compiling and fluctuated while running configure.

How about one more test for completeness’s sake?  Here’s GIMP, a complex GTK+ program with many dependencies and a good benchmarking test:

GIMP (2.6.8, after having run ./configure; no ccache):

Building GIMP with prefix=/usr/local, datarootdir=${prefix}/share
Desktop files install into ${datarootdir}

Extra Binaries:
 gimp-console:        yes
 gimp-remote:         no (not enabled)

Optional Features:
 D-Bus service:       no
 Language selection:  yes

Optional Plug-Ins:
 Ascii Art:           no (AA library not found)
 Help Browser:        no (WebKit not found)
 LCMS:                no (lcms not found or unusable)
 JPEG:                yes
 MNG:                 no (MNG header file not found)
 PDF:                 Using PostScript plug-in (libpoppler not found)
 PNG:                 yes
 Print:               yes
 PSP:                 yes
 Python:              yes
 Script-Fu:           yes
 SVG:                 yes
 TIFF:                yes
 TWAIN (MacOS X):     no
 TWAIN (Win32):       no
 URI:                 yes (using GIO/GVfs)
 Windows ICO          yes
 WMF:                 yes
 XJT:                 yes
 XPM:                 no (XPM library not found)

Plug-In Features:
 EXIF support:        no (libexif not found or too old)
 GNOME UI:            no (libgnomeui-2.0 not found)
 GNOME keyring:       no (gnome-keyring-1 not found)

Optional Modules:
 ALSA (MIDI Input):   no (libasound not found or unusable)
 Linux Input:         yes (HAL support: no)
 DirectInput (Win32): no
 Color Correction:    no (lcms not found or unusable)
 Soft Proof:          no (lcms not found or unusable)

ersin@istanbul:~/vorpo/build/gimp-2.6.8$ time make -j7
...
real    2m59.657s
user    9m7.560s
sys    2m24.910s
ersin@istanbul:~/vorpo/build/gimp-2.6.8$

The numbers speak for themselves.  Best yet, the finished binary runs flawlessly after make install.

Benchmarks (graphics)

Since this is not a gaming rig, I couldn’t care less about FPS.  But what’s a review without some graphics test?  Here’s fgl_glxgears (AMD’s proprietary glxgears):

ersin@istanbul:~/vorpo/build/buildroot-2010.02$ fgl_glxgears
Using GLX_SGIX_pbuffer
2221 frames in 5.0 seconds = 444.200 FPS
2466 frames in 5.0 seconds = 493.200 FPS
2779 frames in 5.0 seconds = 555.800 FPS
2943 frames in 5.0 seconds = 588.600 FPS
2950 frames in 5.0 seconds = 590.000 FPS
2946 frames in 5.0 seconds = 589.200 FPS
2943 frames in 5.0 seconds = 588.600 FPS
2912 frames in 5.0 seconds = 582.400 FPS
^C
ersin@istanbul:~/vorpo/build/buildroot-2010.02$

I downloaded Nexuiz 2.5.2 and played the first level (DM1) with the FPS meter on.  I set all the quality features in the ATI Catalyst Control Center to full (4x AA, “quality” adaptive AA, 16x anti-ISO, “quality” mipmap) and set Nexuiz’s resolution to 1280×1024 and its “Effects” to Normal, Good, and Ultra.  At Good and Ultra, running around empty halls got around 20-35 FPS while fighting one bad guy was around 20 FPS, dipping down occasionally to 11 FPS.  With only one baddie, this was playable, but online in a deathmatch it would be unacceptable.  Normal quality was perfectly acceptable: empty halls were 40-60 FPS and fighting one bad guy was around 30 FPS.  I didn’t bother turning the ATI Catalyst quality settings down at all, and I’m sure that the speed would increase significantly.

I also did a test run of Quake Live (Q3 running inside your browser) and everything worked flawlessly, except when I was compiling and the screen started to flicker.  Lesson: don’t play 3D games while compiling (duh).

Noise

Noise was a secondary concern for me, since I don’t intend to have this machine on 24/7, and subjectively on a scale of 1-10 with 1 being my fanless Nokia N800 internet tablet and 10 being my mom’s overclocked Pentium 4 Prescott machine with a Thermaltake Volcano 5, I rank my machine at 6 when idling and 7 at full load.  It’s clearly audible from the other room, nearly 10 meters away.  When I get up close to the computer, it’s unclear whether the bulk of the noise is coming from the case’s stock system fan or the Zalman CNPS7500-Cu (I think that the Tomahawk is fairly silent).

A word on the Zalman cooler.  The CNPS7500-Cu comes with the Zalman Fanmate, which allows for manually adjusting the fan’s speed.  According to its review on FrostyTech, the CNPS7500-Cu when tuned down with the Fanmate to its minimum speed comes in at 32.5 dB, which is practically inaudible and nearly the quietest CPU cooler on their list as of July 2007 when the review was published.  However, I’ve been running the fan at full speed, which is somewhere around the middle of the pack at 50.9 dB, still quieter than the ear-splitting stock fan that comes with AMD’s older AM2 socket processors (the AVC Z7U7414001, 63.0 dB).  AMD seems to have changed the stock fan on the Phenom II to the AVC Z7UH40Q001, which I have not tested and do not intend to test now that my CPU is set up.  My primary concern is not noise, but rather that my CPU stays as cool as possible to maximize its life; that said, the Zalman CNPS7500-Cu should be a fine choice if you want to run its fan at a lower speed.

Why choose the CNPS7500-Cu, then, if I wanted to buy an aftermarket cooler?  I was originally going to buy the OCZ Vendetta, which has been on sale at MicroCenter for $15 and is very highly regarded, but since I’ll be moving soon I wanted to build a small mATX system that wouldn’t be able to fit the Vendetta’s enormous heatsink.  Rather, the Vendetta would fit (barely), but Zalman’s radial designs are more horizontal and allow for better airflow in such a small case as the Elite 341, not to mention that they keep a lower center of gravity and that I was terrified that the Vendetta would snap off (I’ve read on Newegg that it even needs special mounts for some boards).  On a purely subjective level, I enjoy that the heatsink is all-copper and feels almost as heavy as a bowling ball in my hands.

Conclusion

The Phenom II X6 is wicked fast for compiling on Linux, and GCC/make does a phenomenal job (no pun/s intended) at splitting builds into parallel tasks to leverage all six of the X6′s cores.  AbiWord, a modern full-fledged word processor, compiled in less than 2 minutes and buildroot, a system for creating cross-compiling toolchains, finished in less than 20 with the full GCC suite.  Moreover, at $200/$300, the X6 has no competitor in its price range, the nearest being Intel’s Core i7 9xx series, which costs +$1000.  I highly recommend the X6 for any open source Linux work that uses GCC and make.

Aftermath: what review is complete without photos?

Can we tell the creation of man in Ruby?

To begin my project to write history in Ruby, I’ve taken notes on a short passage on the Biblical account of the creation of the world and included commentary that begins to explore the issues involved with writing non-programs in a programming language.  The result is not just notes or code, but a new way of evoking emotions and some early glimmers of a new kind of literature.

—

Why Ruby?

Before I get into the code, I’d like to comment on my selection of Ruby.  For those who are uninitiated, Ruby is a scripted language perhaps most commonly associated with large Web 2.0 projects (like Twitter), but is also a powerful general purpose language for writing all kinds of programs.  It has a hard-earned reputation of being fun and “natural” with clutter-free syntax and intuitive features.  For instance, a for loop in C such as

for(int i = 0; i < 10; i++)
{
  printf("Hello!\n");
}

can easily be written in Ruby as the following:

10.each print "Hello!"

Such aspects of the language encourage a more interactive, to-and-fro, and downright zippier style of programming known as agile development.  In the business world, agile development encourages creating prototypes for clients rapidly while constantly changing and tweaking them based on continual feedback rather than a static plan fully predetermined from the beginning.  This often means that Ruby-coded programs are light on initial design and emerge organically, a tendency which would seem to heed Bruce Blum’s observation that in programming the design and the product are the same.

I would amend Blum’s insightful principle by asserting that a program’s design and the program itself are, for most purposes, practically the same, and in this respect Ruby more closely resembles written natural languages than any other programming language.  Perens’s point was that when creating software, we can imagine that the code is a blueprint for the program, which in actuality is a set of instructions that we want the computer to execute.  Since the code is the set of instructions, however, the blueprint and the program are equivalent.  Yet even before we begin to code, whether there is a formal design phase or not, undeniably the coder imagines in broad strokes what “should happen”, and it is this pre-design “phantasmal ratio” that gets distorted in the coding process.  Surely for each programmer it is something different; for me, I often see images of gray windows and frames moving around, and when I contemplate iterations I feel a soft, upward tension in the back of my throat and a warmth where my head meets my neck.  These are incommunicable regardless of language, and yet from thence does the code come out.

Isolating and defining what mental or spiritual paths or processes the code uses to come out seems nigh impossible, but I do feel that when it does come out we can either be equipped with a language that first demands pseudo-code, which seems like an extension of the pre-design phantasmal ratio into design proper, or it can be birthed straight into real code if the language is prepared or ready enough.  Ruby is ready to receive the code directly just as natural languages are also ready to communicate our imagination and our thought immediately, as when we speak in a conversation, and this is why I’ve chosen Ruby for my project.  This ability to receive our mental impressions more immediately than at least the programming languages that I am familiar with is, in my opinion, greatly responsible for Ruby’s tendency toward agile development, which is another similarity with how natural languages are used and yet another reason to use Ruby to write my notes.

In Principio: notes on the Christian creation of the world

For my first attempt, I’ve selected a short passage from “In Principio: The Creation in the Middle Ages” (in “Approaches to Nature”, ed. Lawrence D. Roberts.  Binghamton, NY: 1982, Center for Medieval & Early Renaissance Studies), a scholarly article by Dorothy Glass on approaches used by medieval artists’ to depict the Biblical account of the creation of the world.  My intention for this initial example is not to create a thorough set of notes covering the entire piece, but rather a focused exposition of some of the issues involved in coding one’s notes in Ruby.  By no means is my list exhaustive; as a matter of fact, perhaps the greatest obstacle is that I am so aware of how creative an act my project is (even though it is no more creative than any other), a creativity which I have endeavored to protect by limiting my own commentary.  Some of my decisions will undoubtedly, therefore, seem controversial, and I hope that the reader will meet my creativity with their own uninhibited and unwittingly creative notes and observations.  The passage is as follows:

“The creation stands at the beginning of all nature.  In the Middle Ages, the Hexaemeron, or six days of creation, was both a topic of extensive debate and the subject of innumerable illustrations in all media.  Interpretations of creation both written and visual encompass theology, philosophy, mathematics and even architecture — in fact, virtually the entire intellectual life of the Middle Ages…

The creation, as recounted at the beginning of Genesis, is seemingly well-known, and one can easily visualize a series of illustrations depicting the days of creation.  In actuality, chapters 1 and 2 of Genesis are drawn from different traditions.  Chapter 2 repeats some of the essentials of Chapter 1, but also offers conflicting information and interpretations.  The text must be carefully analyzed in order to appreciate the problems faced by medieval artists in their attempts to envisage the story.  It will soon be evident that medieval artists must not be viewed as mere illustrators.

For example, during the six days of creation recounted in Gen. 1, God actually performed eight separate acts.  On the third day, He created not only the dry land (or earth), but also grass, seeds, and fruits.  On the sixth day, He created the beasts of the earth and both man and woman who were given dominion over them.  The artist was thus faced with a choice of events to be depicted with the canonical six days.  The solutions to this problem are myriad.” (pp. 67-8)

My first thought: creation is the first node in a linked list.  What does that mean?  The list could contain objects all of the same type, perhaps of class “Event”.  The structure of a linked list is linear, which is appropriate for a Judeo-Christian conception of time.  Add a link back to the first node at the end and we have a Greco-Roman history, a loop.  Should the list be doubly linked?  No, at least not in any publicly accessible way.  So we start:

class TheCreation

(NB: Ruby classes are CamelCased by convention, which wreaks havoc with semiotics.)  Right here, I get distracted by the eight acts during the six days of creation that artists had difficulty portraying.  A hash would be a perfect way of representing both the difficulty and the objective of those artists.  Each stained glass window and its depicted scene is like a key pair, but if there are eight values then how do we assign them to only six keys?  We continue:

class TheCreation
  days = {

I’ve started to write the hash, but now there’s a bevy of problems.  First, one related to Ruby itself: hashes, arrays, and other variables cannot be declared within a class while outside of a function.  The Ruby way of doing what I’m trying to do here would be to initialize the hash at the time of the initialization of a TheCreation instance, but this is a little absurd.  Were the numbers of days and acts and their assignments determined at the moment of creation?  More importantly, the Biblical creation was unique, but with Ruby, I can create as many instances of TheCreation as my memory can hold (seems like Plato had something with his theory of recollection).

Another problem involves scope.  Ruby allows instance, class, and global variables, each of which has problems.  Using an instance variable for the hash is perhaps most objectionable, as it further ramifies the error of multiple creations.  A global variable might be more appropriate, but the fact that it is accessible from anywhere means that everyone has a direct connection to God, which is downright Protestant, not to mention that any method could fidget with the hash, assigning new key pairs and so forth.  A class variable seems reasonable, but then the variable won’t exist before an instance of TheCreation is initialized, whereas God might have prefigured the days and acts before the moment of creation.

In fact, all of these issues were hotly debated by medieval scholars, only in terms of theological constructs rather than variables and instances.  Attentive readers will have also noticed some of the same patterns in the argument above can be found in medieval treatises, such as the reductio ad absurdum and a way of treating language that vaguely resembles suppositions.  Is the resemblance coincidental, or are programming and medieval theology (or forms of argumentation) intrinsically linked?  Perhaps it simply boils down to the bias of my own methods in collusion with the medieval content of the subject matter I am studying.  That is, since I know high medieval writings, I pattern my commentary (indeed, my commentary) around them whenever anything medieval and intellectual is to be discussed.

Coded notes as poetry

I suspect that my bias is an important part of the answer, but only one part.  Language is infinitely flexible and can be used here as both commentary or art, for instance, since the dividing line is so thin.  Were I to abandon the mimetic aim of my notes and go with whatever feels natural, all of a sudden my coded notes become an unexpected statement, an unthought idea; a poem:

class TheCreation
  attr_reader :days

  def initialize
    @days = { :day1 => nil, :day2 => nil, :day3 => nil, :day4 => nil, :day5 => nil, :day6 => nil }
  end
end

c1 = TheCreation.new
c1.days.each { p "Hello, world!" }

Then, and only then, do the scholars come in stage left with our expert opinions on the act of creation.  Here, rather than posing a problem, the infinite flexibility of language allows us say that we were right all along, just as the scholastics did.  Why did I initialize the days hash with instance-wide scope?  Because, in fact, multiple instances of TheCreation, or at least multiple universes in the sense that the universe contains and is everything, are possible since God is omnipotent, and this has been the official position of the Catholic church since 1277 when Étienne Tempier, bishop of Paris, issued his condemnations prohibiting the theological faculty at the University of Paris from debating certain “errors” of Aristotelian philosophy including the uniqueness of the world (the eternity of the world having been a prohibited belief since 1270).  For the same basic reason, we can also rule out the need for a doubly linked list of events with TheCreation as the first node.  Finally, the entire question of scope can be handled within the framework of suppositions, where $days (global) is in simple supposition, @days and @@days (instance and class) are in personal supposition, and :days (symbol) is in material supposition.

Yet my code stands outside of these attempts to reconcile my text with the Bible, and if we contemplate it independently, doesn’t it have a curious force of its own?  Is it a farce that God’s six days of creation are merely symbols in material supposition that are matched with nil values?  And when the user runs the program, it outputs what the artist wants her to see, in this case “Hello, world!” for each day of creation.  Programmers will get the reference: writing a program that prints “Hello, world!” on the screen is the classic “first program” that one writes when first learning a computer language.  Am I suggesting, then, that I am newly learning Ruby, or perhaps that God was just getting his grips on creation when he made our world?  When I contemplate this, I am moved to wry laughter and my soul feels a bit nourished.

Maybe the power is relative and I am the only one who feels this way about my code.  Certainly my experiment has not been the first to formulate commentary in computer code, though I have not found other samples as stirring as mine.  An example that has always stuck out in my mind is the snippet at Rastasoft, which features the following lines of C superimposed against a red, yellow, and green flag background:

while ( love & passion ) {
  for( fight = 0 ; rights < freedom ; rights++ )
    fight = standup( rights );
  free( babylon );
}

Why does this code not move me?  It should be noted that the author has even gone out of the way to appeal to our sensibilities by using the technically incorrect expression “love & passion” instead of “love && passion”.  Well, not incorrect, but using one ampersand has a completely different meaning than what is intended, which is loosely translated into English as “while there is love and passion, we will stand up for our rights, fighting from nothing until we’ve attained freedom, at which point Babylon will be freed”.  Quite a stirring anthem, except that my translation falls short of what is actually going on in the code and the assumptions that we must make if we are to take this line of thought to its logical conclusion.  Standing up for our rights does not involve our actual rights but merely copies of them (passing by value) and what matters is the number of rights we have instead of the specific ones (“rights” is an integer, the for loop’s exit condition is when rights is incremented up to a certain value).  Nor are we technically standing up “for” our rights, but really we are using our rights or the issue of our rights as the basis for our act of standing up.  For that matter, when we say “fight = standup(rights);”, literally we are saying that the fight should “become” (be assigned) the outcome of standing up while using our rights rather than what is presumably intended, which is that standing up for rights is the fight (which, in turn, would be closer to something like “fight == standup(rights);” or even using function pointers using “int (*fight)(int) = standup(rights);”).

That batch of nonsense, which I have admittedly tweaked to give a slightly negative-sounding tone and hence a semblance of poetic meaning, is partly a result of the author’s ambiguous liberalities with the programming language, but also partly the necessary outcome of C’s weird syntax.  The need to go through a linear progression of gaining rights until we reach freedom necessitates a for loop, which is the most direct way to increment continually, while in Ruby we might more naturally use a variable’s “each” method.  That would also free us from having to represent rights as a number.

What’s missing from both my code and the Rastasoft code, however, is a compelling dramatic narrative, more so for the latter than the former.  That’s no surprise given that one is just a set of notes and the other is almost like a motto or a rallying cry, and more code would certainly leave room for a plot with different actors (classes).  Indeed, the beauty of coding notes or literature might be the possibility of combining classes and objects into new orders, connecting them by passing variables and overloading methods, etc.

Stay tuned for part three!

A new way to program?

This blog has often focused on how an incomplete revolution in digital formats has prevented the birth of digital art, but recently I’ve been pondering whether the problem lies in the lack of dramatic narratives in digital media, or in other words directly in the content.  Phrased differently, perhaps the right formats surround us, but we’re using them in the wrong ways.  The only way to find out is to start writing my thoughts computerally.

—

Format Needs Content, Content Needs Format

As I’ve argued before, format and content feed off each other symbiotically in information technology, and the migration from the codex to the computer as our main information tool has disrupted the cycle that books have incrementally generated over thousands of years.  Specifically, the abrupt change in format has forced computer systems designers to borrow and artificially impose many paradigms from the paper world and even the “real world” on the digital one (e.g., the desktop, pages, tabs, e-readers, virtual reality) without having had the chance to develop paradigms autocthonous to the computer.

In lay terms, we’ve developed eBooks but we have yet to create the “eE”, and therefore our content and our experience of that content suffers.  MMORPG players and serial Wikipedia clickers suffer vague feelings of emptiness despite hours of immersion whereas a book reader (or, relative to World of Warcraft, a LARP’er) almost never complains about the same ailments despite the fact that the content in the digital medium often closely mirrors its analog counterpart.  This, I have argued, merits a broad and deep inquiry into how we can create new digital formats to enrich our souls the way books do.

Finding the right format for gripping narratives

While discussing the matter with my father, however, he brought up the point that digital media often lack the same compelling dramatic narratives that we find in print, which is perhaps the real reason why the Web can be so dry rather than its format.  The discussion page for the Atassi article on Wikipedia is a salient example where two family members have engaged in a gripping struggle over the identity of their family and each other in a public forum on the Internet.  Yet in addition to unusually good content, the format takes on a strangeness of Tristram Shandy-esque proportions and has a lasting impression on the reader, even if he is unfamiliar with Wikipedia’s protocols: the table of contents with the rows of equal signs, the impromptu divisions between epistles, and the body’s unnatural length compared with the height of the page’s chrome on top.  Is it the format or the content itself, then, that has the greatest impact on our experience and understanding of the text?

Such a question assumes an opposition that seems antithetical to the very premise of our inquiry, that format and content help shape each other, and the truth must lie somewhere between.  We might come at it from the opposite direction, as an creator who wants to express themselves digitally.  That is, she has the content and wants the format, but a format that will be truly unique to her computer, leveraging the computer’s unique properties and capabilities.  She wants something beyond digital, in fact; she wants something computeral, a format that is meaningfully tied to the electrical whole that is more than the sum of its integrated circuits.

Could there be any brighter candidate than a computer program?

The notion of a computer program as art poses serious difficulties from an analytical point of view.  A program is essentially a set of commands for manipulating and coordinating the various parts of a computer to achieve a desired effect.  Taken to its logical extreme, the program is a definitive solution to a problem, something that at least Microsoft has recognized by billing what would be called a “project” in the traditional nomenclature of an IDE as a “solution” in Visual Studio .NET.  Art, on the other hand, is crisis, and it manifests itself in more than just the imperative mood.  How would you translate Hamlet’s indecision into assembly, or the Greek middle voice into C (despite the fact that C is a weakly typed language)?

From the artist’s standpoint, however, doesn’t the moment of creation surpass all arguments?  Sophie Denoël in J.M. Coetzee’s Summertime notes that the mark of a great author is his ability to deform the medium.  I suspect that we can use programming to create great art, but that no one has done so yet.  Thus, I’ve decided to try and start write computerally, that is, to program my thoughts and artistic impulses to see where it leads.

Coding history in Ruby

My recent admission into a graduate program in history offers the perfect opportunity, and for the next month, I will be programming my reading notes in Ruby as well as taking notes on the process.  I’ll post the results and the code up here in a series of articles that will detail my thoughts and emotions regarding the subjects I’m reading about as well as the process of computeral writing itself.  “How?” is not a question right now, and should a method arise from the madness it will be well-documented.  Until then, I will simply “dig in” with only my inspiration and my whims to guide me.

P.S.: This article’s title refers to the common tagline plastered across various WordPress and programmers’ blogs.  There might just be something to it.

Apple I computer. Image courtesy of Ed Uthman, taken from http://commons.wikimedia.org/wiki/File:Apple_I_Computer.jpg, used under the Creative Commons Attribution-Share Alike 2.0 Generic license.

Apple’s recent iPad announcement has sparked not only commentaries on its design, but also deeper reflections on the increasingly strained relationship between computer interfaces and innovation.  Will the abstraction of interfaces and data kill off homebrew and how will that affect digital creativity?

—

Apple, Google, and the death of homebrew

Apple’s recent iPad announcement has sparked not only commentaries on its design, but also deeper reflections on the increasingly strained relationship between computer interfaces and innovation.  For most users, the increasing abstraction of GUI’s from a computer’s internal processes is perceived as a benefit, since they would never have wanted to learn how a CPU moves bits of memory or a video adapter draws figures on the screen; or even, as the iPad suggests, how to manipulate windows.  Yet it has been precisely the necessary evil of dealing with such nitty-gritty details that has lured the world’s greatest programmers and system designers to computers in the first place.  As renowned blogger and Google programmer Mark Pilgrim writes in the “Tinkerer’s Sunset”,

“Today I am a programmer, a technical writer, and a hacker in the Hackers and Painters sense of the word. But you don’t become a hacker by programming; you become a hacker by tinkering. It’s the tinkering that provides that sense of wonder. You have to jump out of the system, tear down the safety gates, peel away the layers of abstraction that the computer provides for the vast majority of people who don’t want to know how it all works. It’s about using the Copy ][+ sector editor to learn how the disk operating system boots, then modifying it so the computer makes a sound every time it reads a sector from the disk. Or displaying a graphical splash screen on startup before it lists the disk catalog and takes you to that BASIC prompt. Or copying a myriad of wondrous commands from the Beagle Bros. Peeks & Pokes Chart and trying to figure out what the fuck I had just done. Just for the hell of it. Because it was fun. Because it scared my parents. Because I absolutely had to know how it all worked.”

Yet it’s not just Apple that’s killing the tinkerer, but also Pilgrim’s employer Google, which by isolating raw data from users is doing to data what Apple has done to the computer’s guts.  Google’s entire business model depends on retaining and manipulating personal data exclusively through their tools, and at its most extreme the company aims at a new status quo for data in which information is completely out of a user’s hands.  More reactionary than revolutionary, the design of Google’s Chrome OS, announced in November 2009 and due to ship on netbooks later this year, hearkens back to the forty-plus year old terminal-mainframe model of computing where users merely access a common central server through a keyboard and a monitor rather than owning and controlling their own computing power.  As for Google Books, while it has rendered millions of works accessible over the Internet, the project’s vision is perhaps even more profoundly reactionary as it seeks not only to hold the world’s digital data but to dredge it up from analog formats.

Google’s services have virtually eliminated the need for money, education, and technical capacity, the traditional barriers to accessing and manipulating information, as effectively as Apple’s products have made training, aptitude, and prowess irrelevant when using a computer.  Yet in tearing down these roadblocks, they’ve patented the road and trademarked the road signs, even though Apple and Google were instrumental in the liberation of computer and Internet resources that enabled countless innovative projects to sprout during the 80′s and 90′s.  Open source software advocates would call Google “free as in beer” but not “free as in speech” (Apple being neither), yet both companies were founded by tinkerers working in garages working with abundant and nearly free off-the-shelf components and ideas.

How important is homebrew, anyway?

How then could these homebrew heroes of the digital revolution create an environment so hostile to the kind of efforts that have seeded computer innovation, and how will that innovation change?

History shows that middlemen prosper in greater numbers than producers.  The tactical brilliance of Apple and Google is that they have transitioned from being developers and extractors of computing power and raw data to being their organizers and couriers; but their deeper strategic insight was to commodify these resources in the first place.  Especially in Apple’s case, computer hardware and software interface design is no longer an engineer’s afterthought or intuited hunch, but rather a brand, the sellable product of meticulous research and development processes with price tags.

It is tempting to claim that innovation will continue to further root itself in corporate pockets, though that doesn’t mean that every computer company has to turn into Electronic Arts with a purely MBA-driven agenda.  Google has reached an effective compromise between homebrew and professional with its 80/20 system in which engineers spend twenty percent of their work hours pursuing personal research projects (though at least one pundit feels that such a system cannot pay for itself in the long run).  For new startups, however, this may not be as viable as it used to be now that post-bubble venture capital has dried up, notwithstanding the global recession.

Children, design, and mimesis

When talking about how today’s innovators were inspired to write their first code or build their first computer, however, one shouldn’t underestimate a child’s penchant for tinkering.  Children will always be inquisitive, and even if they can’t tinker with Apple’s Torx screw-sealed products or the ordering of Google’s PageRank, they will find their own way to break and remake.

In my own case, I made my first computer program on a Macintosh SE when I was six years old.  I had fallen in love with the classic solitaire mah-jongg game GunShy (1987) and asked my father how to make my own.  He copied the icon on the desktop, we renamed it to “Ersin’s game”, and I waited full of anticipation and wonder as it loaded hoping that somehow the computer had read my my mind and knew exactly what kind of game I wanted.  Needless to say, I was extremely disappointed to see GunShy load, but I wasn’t defeated.  My early failure only spurred me on to find a way to access the computer’s secret sauce, and I kept pestering my dad until two years later one of his friends introduced me to QBASIC — on a nitty-gritty Windows 95 PC.

Fifteen years later, I still have the tinkering bug, but with a twist.  Over a decade of steeping myself in computer guts has made me realize that there are a number of fundamental problems with computer design that can only be redressed at a hardware level, and I’ve started relearning electronic circuits to put together my own projects.  Importantly, in this latest phase I am spurred on by the failure of the slick and smooth as much as I am by the internals.  I take issue with the desktop paradigm, for instance, because like other common computing paradigms in emulating something “real” it fails to tap into the potential and the soul of digital technology, thus stopping short of ever becoming real itself.  Yet, I recognize that, on a fundamental level, a computer’s electrical components are arranged into circuits that can only accept commands rather than express an idea that has its own power and will as a book or a movie can; thus, the combination of billions of these circuits will eventually lead to something like a desktop, a web browser, or some other irritating and unenriching command-based experience.  On balance, the abstraction and the internal processes equally impel me to tinker on an even deeper level than before, and children will similarly want to break something when they encounter the inevitable deficiencies of Apple’s or Google’s latest product lines (hell hath no fury like a child denied).

One might go further by suggesting that the spirit of tinkering could be superseded by a new creativity similar to what we feel when we encounter great works that makes us want to make art ourselves.  Properly speaking, in a mimetic context there often is no tinkering at all since the inspiring work, whether it be by God or man, is frequently beyond our reach either by virtue of its immensity, the cordon in a museum, or the lack of space on a printed page.  Instead, we say that we are inspired; that is, rather than us fiddling with the intestines of the work, the work seemingly breathes itself into us and animates us to create something physically distinct.

That separation between the elements of the creative process doesn’t exist for computers because, as Bruce Blum notes in his book Beyond Programming, in programming the design of the product is the product itself.  A house and its blueprint are distinct, but code written in C is not a design for something else.  It is an abstraction of machine code that must be translated, but it is essentially the finished deliverable, and as such tinkering automatically creates something new.  With sculpting, electrical engineering, or any other craft or art, one can only hope to tinker with the idea behind the work to create a different work.  Perhaps a tamper-proof digital future will instil these old ways of being creative into young minds, which may ultimately prove to be even more potent than the tinkering that has driven digital innovation so far.

The Atassi family's quarter in Homs, Syria

Against a backdrop of political intrigue and coups, one scholar defies his elders to uncover the true origins of his family, the once-powerful Atassis of Syria, now shattered by exile into an international diaspora.  Dan Brown thriller?  Look again: it’s the discussion page of the “Atassi” entry on English Wikipedia.

Family matters

Wikipedia may be the last place to look for the emergence of true digital art: its mission is explicitly classificatory and pedantic and its administrators at times take on all the creativity and zest of a state archive’s apparatchiks.  Yet one mothballed discussion page has preserved a gripping family drama and, in the process, offers us a rare but hopeful example of how digital texts might achieve the raw spiritual and emotional power of books.

The discussion page for the article on the famous Atassi family of Syria, whose members played a prominent role in Syrian politics after the end of the French mandate in 1936 and whose roots go back well into Ottoman times, details two cousins, one named Bassel and another unknown, engaged in a dispute over their family’s history.  As the dialogue goes on, we learn more about each author.  Bassel is a bit of an underdog, and he “was literally told by some that I have no right to write about the family, given that I had never lived in Homs”, the home city and traditional power base of the Atassis in Syria since Ottoman times.  His opponent writes in broken English and remains mysterious, and one subplot that develops is Bassel’s ongoing attempt to learn his name, so that he may “have the honor of addressing you by your first name, the way you are addressing me by mine, since we are trying to be honest with each other.”  At one point, Bassel tries to force an admission by signing with his full name, “Bassel ibn Ahamd Habib ibn Ziad ibn Khalil ibn Khaled ibn Mohammah Atasi”, but in the end the unknown writer refuses and makes a remarkable confession:

“Basel

I cannot share my name with you especially because you had attacked me repeatedly …I know that we came to agree at the end but yet again, you questioned my motives already which put me in an awkward position with my other Atassi friends . I know of you and I know many of your cousins and I don’t want to cause senilities. Let’s keep it professional and informative.

Regards”

At times the fight can get nasty, and Bassel’s opponent compares Bassel’s tone to the “Mukhabarat of Syria”, the infamous Syrian intelligence agency no doubt used by the Assad family to hunt down and ferret out the Atassis and other dynasties in their quest for power (what anger must that name strike in Bassel’s heart?)  Yet there are also remarkable signs of cooperation and conciliation when the two parties work together, as when Bassel writes “In show of cooperation, I will not make these changes and will wait for you to do them yourself as you see fit” regarding the origins of the Atassi family’s name.

Flouting Wikipedia

Above all, however, what makes this dialogue such a gripping read is its utter disregard for the format of the medium and Wikipedia’s conventions.  In their intentions, both writers are wildly off from the discussion page’s purpose as a venue for voicing editorial concerns, which is translated so vividly into a stark ignorance of how to use the tools and the markup language provided for them to insert subsections, signatures, and so on.  The very first thing the reader encounters at the top of the page is an absurd table of contents:

Contents [hide]

1 Naqabat Al Ashraf

1.1 =====================================================================
1.2 =================================================================================
1.3 ===========================================================================
1.4 ============================================================================

…

This psuedo-introduction arrests anyone who is used to the standard formatting of Wikipedia like a casual reader flipping through Tristram Shandy for the first time.  There is a whiff of crisis here, not only in the content that follows but immediately here in the medium as well, a distinct flavor of dada.  Unlike dada, however, this is no conscious rebellion, and when one checks the “edit this page” tab it is clear that the authors decided to separate their epistles to one another with lines of dashes, like so: ——————————————–.  These are interpreted as being the titles of subsections, hence the strange autogenerated table of contents.  Indeed, using lines is a necessary strategy to keep their correspondence organized since neither appears to be aware of the four tildes (“~~~~”) shorthand, which associates a username and a timestamp with each change to the page.

The resulting play between notation strategies and hierarchical organization effectively alters the content, and not simply in the sense that differences in notation affect the text.  On an interpretive level, the content informs the reader as he begins to question the author’s formatting choices, and vice versa.  Why would she use the dashes when the edit page explicitly reminds writers to “sign off” each change with the four tildes?  Could they have wanted to keep their identities secret, especially the unknown writer who hesitates to tell Bassel his name?  Was the decision simply a result of their ignorance of the medium?  Consider the frank admission in the first letter,

“test

I am not sure how to engage in a discussion here….this is an attempt.”

The shock of failed expectations, the importance of format, or the triumph of content?

Such formatting errors suggest a polarity between the reader’s expectations and the format’s structure, or perhaps more broadly between the subjective and formal qualities involved in the reader’s perception of the narrative.  Without a doubt, the mistakes arrest you in a haunting way, as if one had gone into their storage shed out back and saw the boxes unpacked, the spare folding table unfolded, and the dishes and silverware perfectly set out for dinner.  We may be seized with terror, pleasure, or any another emotion, but when we take pause is it only because of the incongruity of a table with place settings in a shed or also because the arrangement possesses something gripping and remarkable?  Is our astonishment due to a passing cognitive dissonance, or does the cramped, intimate, and fume-drenched environment inspire a new dining experience, one that might even call for new recipes (what Riesling goes best with the odor of acetone)?

Time breaks down the betrayal of preconceptions, allowing room for the true potential of a medium to sprout.  But how much time will the Atassi discussion page need?  It poses the problem of canonization reduced to scale: will this Wikipedia page still haunt us a week from now, and fifty years from now could we write about it as the ancestor or prototype of digital literature?  Or will it disappear into the white noise of Wikipedia, blogs, and history?

Yet beyond these experiential considerations there is still the obvious issue of whether this narrative might be gripping purely because it is just good drama.  The ephemeral nature of Internet discourse is so often due to its banality, from the great wastes of 4chan to the canned humor of bash, not to mention the lack of narrative, period.  More specifically, the fractured nature of the interwebs lacks the unity of action so critical to plot, to which the Atassi discussion page is a rare exception.  The format, perhaps, is less relevant.

It would behoove the world to conduct large scale studies to see how the experience of reading literature is affected by the medium and the layout of the content.  Studies have been done within a usability context, but not to my knowledge with “literary” literature and certainly not with an eye toward emotional and spiritual effects, let alone comparisons with the effect of other media like paper.

My hypothesis is that content and format are distinct but exist symbiotically the way mind and body or, going back to the storage shed analogy, Riesling and acetone fumes do.  The extent to which each affects each other and also our reading experience is another question, one that is difficult to evaluate using just the Atassi discussion page as a sample.  Like so many chance discoveries, however, the answer to whether the page offers an solid new model for digital narratives may just depend the brute force of billions of other Atassis putting down the keyboard, giving it a go, and seeing what comes out.

]]> http://www.whatdigitalrevolution.com/?feed=rss2&p=79 3 http://creativecommons.org/licenses/by-nc-nd/3.0/us/ http://www.whatdigitalrevolution.com/?p=35 http://www.whatdigitalrevolution.com/?p=35#comments Thu, 17 Dec 2009 01:36:27 +0000 Ersin Akinci http://www.whatdigitalrevolution.com/?p=35

In response to antitrust concerns, the European Commission has mandated that European versions of Microsoft’s Windows operating system allow users to select their web browser from a “browser ballot”.  Yet at stake is not only the future of the market, but also how many new computer users will love and grow attached to their systems.

—–

Microsoft and its latest European tussle

Earlier this year, Microsoft offered to implement a browser ballot in European versions of their Windows operating system in response to pressure from competitors and the European Commission (EC) to foster competition in the web browser market.  The ballot would pop up in a window after installing an update, allowing consumers to choose from a predefined list which web browser they would like to use, presumably by clicking the icon of their preferred program.

Implementing the ballot has not proven simple, however, and Microsoft finally reached an agreement with the EC addressing several concerns expressed by competitors Google, Mozilla, and Opera about its design.  According to the original plan, the browser ballot would have listed its options alphabetically, which raised fears that Apple’s Safari would gain an unfair edge.  Moreover, the form itself was to be displayed as a web page in an Internet Explorer window with the Internet Explorer logo in the upper left hand corner, further biasing consumers.  By fixing these issues, Microsoft has ended its latest European legal tussle over its anti-competitive business tactics.

Yet as with all icons, the browser ballot carries ramifications beyond legal compliance by introducing a completely new subjective experience to the average Windows user.

More than just business: every symbol has a meaning

The visual act of choosing your browser from a ballot rather than simply accepting the default or going through the Internet to install an alternative will reaffirm the trend toward browser-centric and browser-only computing experiences.  Especially for Internet Explorer users, Microsoft’s announcement sounds the death knell for one of its oldest, most innovative, and most poorly implemented visions: the seamless integration of the Web with the desktop.  This may not matter much for established users who encounter the ballot as an update, but it may weaken the desktop metaphor for first-time PC owners who would presumably see the screen after first turning on their computers.

However, such as selection could also be an affirmative action that empowers and ennobles the user, who not only chooses a tool to use for accessing the Internet, but in effect decides her guiding force and her digital plenipotentiary.   The ballot is more than a choosing, it is a voicing that implies taking sides and fealty deeper than computer fanboyism.  It is a visual contract between to sovereign powers with obligations and expectations.

Being not only visual contract but a pictorial one, the emotive strength of the browser ballot is intrinsically connected to the layout of its icons.  Consider Microsoft’s older proposal, as posted on Mozilla interface designer Jennifer Boriss’s blog (October 15th, 2009):

Original Microsoft browser ballot design

Not only is this design weak from a usability and fairness perspective, as many including Boriss have noted, but it also closely simulates standard non-empowering and unemotive click paths for installing web browsers.  Like installing an alternative browser today, it makes the user conscious of the technical installing and informing processes with its prominent “Install” and “Tell me more” buttons.  Moreover, the user must go through an essentially verbal selection process by reading through the textual elements that dominate the page over the icons.  This design is much closer to Microsoft’s terminology of a “Choice Screen” as a literal Wahl rather than the deeper motion to affiliate oneself with a larger body inherent in a ballot.

In contrast, Boriss’s proposal in her post dated November 2nd dramatically simplifies the layout above:

Boriss's proposed design

Choices here are formulated presented within a top-heavy hierarchy emphasizing each browser’s pictorial representation.  Text is subordinated icons, and even within the text different layers are distinguished by size.  The layout’s principles are opposed to, for instance, the rhythms found in Roman aqueducts or Romanesque facades where larger arches containing bigger swaths of negative space support successively finer and smaller arches.  In the polarized visual environment of the ballot, the positive space shaped by columns of text topped by buttons and logos evoke the stem, calyx, and blossom of flowers, or architecturally the tradition of Frank Lloyd Wright’s lily-pad columns in the Johnson Wax Building rather than the simulated entasis of hierarchically arcaded building fronts.  By making his choice, the user moves beyond technical jargon and legalese, implicitly associating himself with the generative and vegetative power of one of these browsers via their colorful icons, not their cold descriptions.

Heraldry and digital ballots in video games

Boriss’s design evokes heraldic traditions, as well, which have long engendered feelings of loyalty and partisanship through digital ballots in computer games.  Consider the venerable family selection screen from Holistic Design’s classic medieval trading simulator remake, Machiavelli: the Prince (1995):

Machiavelli: the Prince family crest selection dialog

This is the screen each user faces when starting a new game, and its effect is immediate and powerful.  Significantly, it follows a dialog box for selecting a family name from a list, yet the effect of choosing a name from a text list is far less impressive than picking a crest, the experience of which is nothing short of intoxicating.  Surely the force of the graphical dialog box comes not only from an enhanced sense of historical association, but also a heightened feeling of belonging and allying, which reminds the user of his own agency through engaging it.

The same psycho-semantic processes are at work within Boriss’s design, and moreover Machiavelli‘s ballot shares the same layout principles common to any strong ballot.  A top heavy format again evokes the calyx and the blossom, and although lines of text occupy the top this is mitigated by the use of monospaced bitmapped fonts that dissolve the words against the marble and black backdrop and allow the inviolable crest buttons to float dominant.  The subtle raised hint on rollover also bears a resemblance to the bubbled “Install” button on the browser selection window, though neither are as obvious or taxing as the button hints in Microsoft’s design.

Beyond selection

Similar to the medieval crest selection screen, Microsoft’s new browser ballot has the potential to significantly contribute to the emotional experience of new PC users who could move beyond selection to actively identify with one browser or another on a spiritual level.  This is not to mention the empowerment of consumers by affording them more choice.  It is important, however, to remember Umberto Eco’s comparison between DOS and classic Mac OS in his 1994 column in the Italian daily Espresso:

“The fact is that the world is divided between users of the Macintosh computer and users of MS-DOS compatible computers. I am firmly of the opinion that the Macintosh is Catholic and that DOS is Protestant. Indeed, the Macintosh is counter-reformist and has been influenced by the ‘ratio studiorum’ of the Jesuits. It is cheerful, friendly, conciliatory, it tells the faithful how they must proceed step by step to reach–if not the Kingdom of Heaven –the moment in which their document is printed. It is catechistic: the essence of revelation is dealt with via simple formulae and sumptuous icons. Everyone has a right to salvation.”

The browser ballot’s ultimate promise of salvation from the online wastes of inundating levels of online information will depend on the configuration of its all-important icons.  Whether a ballot can deliver on that promise is up to the politicians and the developers.

The world is witnessing an epochal transition from the codex to the computer screen as society’s main information paradigm.  Yet the true “digital revolution”, from using computers as information tools to living with them as art and as worlds unto themselves as we do with books, has yet to begin.  Before we can do so, we desperately need a new science to deal with digital issues appropriately.

——–

The failure of science: not wrong, but just missing the point

Grappling with the social and emotional impact of computer technology is a slippery issue that researchers simply haven’t been able to get right.  Last month, Professor Keith N. Hampton at the University of Pennsylvania’s Annenberg School for Communication released a study that suggests that the spread of digital communications via the Internet, text messaging, and so on has not increased social isolation.  According to Professor Hampton, his study was in response to a June 2006 article published in the American Sociological Review that suggested that social isolation among Internet users had actually increased, a finding more in line with common wisdom.

The problem with both Professor Hampton’s research and the ASR article is that they both focus on social isolation as a quantitatively measurable factor, whereas the real point they both miss is how digital technology makes us feel.  What is commonly termed as “social isolation” is a misnomer, a label for a feeling of great emptiness within us even after we immerse ourselves in the Internet for hours at a time.

Compare browsing the internet to its nearest analog analogue, reading a book.  Avid readers shut themselves in for hours, even days at a time to get lost within their favorite author’s pages.  Yet whether they emerge refreshed or exhausted, they come out feeling connected, full, and in a different level of being.  Even reading non-fiction like the encyclopedia or a newspaper seems to nourish us more than Wikipedia or the HuffPo do, though statistically they may have the same number of words, readers, or impact on IQ.  This truth will always elude quantitative methods.

The failure of the humanities: too many nouns, not enough verbs

Qualitative assessments of human emotions might be expected to be the domain of the humanities, but here too we have failed with respect to digital technology.  Scholars have been active studying  the immersiveness of computer-simulated virtual reality and the semiotics of hypertext versus printed books, to name but two common fields of inquiry, but they have yet to recognize the computer as an altogether separate and autochthonous kind of work itself.  Thus, they are unable to penetrate new ways of relating digital technology to our emotions and our souls because their methods and tools are still constructed for the distinct, though interrelated, experience of reading a paper codex.

By the same token, visionaries in the computer industry have largely failed to engender true innovation in the way we relate to computers, focusing almost entirely on a bifurcated track.  User interface development, broadly constructed here as the development of any kind of computer-user interaction, usually goes into making computers more like living in the real world, more like reading a book, or tweaking the experience of either.  In fact, true innovation means finding ways of living, reading, and breathing digital technology in ways still informed by books, photorealism, and everything else, but also in some way uniquely authentic to itself.

Toward a new art and a new science

The long digital revolution to come will inherently be an artistic act, a creation rather than a study of creation.  Nonetheless, scholarship must play a leading role and walk the fine line between stifling creativity and enriching it through respecting the nature of digital technology without trying to define it.

This cannot be done if we still conceive of the computer as an electromagnetic assemblage of pages and folders or of the Internet as a glorified electronic library.  While such assumptions don’t actively try to redefine, they do deny digital technology of something fundamental to itself, something that we may yet have to discover.

The way forward has precedents in the history of art and art criticism.  Consider the writings of Italian Renaissance painters who had to convince society that their craft was as elevated as poetry, then accepted as a gold standard of artistic and philosophical expression.  For modernist art, too, when we read the works of pioneering critics like Clement Greenberg we can see the scholar’s struggle to describe and work with something completely new.