Media Theory for the 21st Century

January 29, 2008

Kittler in Malbolge

Filed under: Discussion — jjpulizzi @ 7:07 pm

Ben Olmstead’s “Malbolge” programming language either challenges or confirms the claims Kittler makes in “There Is No Software,” but I can’t decide which. I’ll lean toward “challenge” since that would probably result in a more interesting discussion. Kittler’s main claim that the internal workings of the computer are obscure and that the Church-Turing thesis means that even reality should be regarded as a digital computer restates the reality and appearance dualism in digital terms. Human beings are just the epiphenomena of an underlying computational reality.

Only having access to the appearance, rather than the reality, the human user cannot claim authorship or control over the activity of the computer (hence we have no control over our writing). While the confusing languages Mateas and Montfort discuss seem to confirm Kittler’s obscurity, one has to remember that a human programmer still wrote the programs and that the authors are able to explain them to the reader. Indeed, they are only obscure because the programmers excavated unused or elliptical ways of writing otherwise common statements. How the source code appears to the programmer makes little difference to the machine code the microprocessor will receive. The obfuscation of the source code and the obscurity of the machine code simply make it difficult—but not impossible—for the human programmer to predict the hardware’s output. Comparing the source code with the output is usually the only way of debugging the program, or making sure it “runs properly” on the computer hardware. The obfuscated code, then, emphasizes that programming languages have conventions and idioms for making the source code comprehensible to all programmers versed in that language, just as a natural language’s idiom makes it comprehensible to other speakers of that language.

Malbolge, however, shows that programming languages not only have conventions to make them comprehensible to the programmer but to the computer. As Mateas and Montfort state, Olmstead’s language is minimalist (making the commands hard to remember and difficult to distinguish from variables or data), uses a trinary machine model, does not execute commands in order, and constantly mutates in memory. The minimalism’s conflation of command and data makes the source code more like the undifferentiated sequence of digits flowing into the microprocessor’s control unit. In this respect, the obscurity of the machine code bubbles to the “surface” of the source code. However, the trinary machine model (when most digital computers use a binary model), the nonlinear execution of instructions, and the code’s constant operation on itself as data in memory mean the Malbolge program will often not run at all. By turning those traits that make the code obscure to the user (no distinction between command and data, etc.) back on the computer, the program and consequentially the hardware become nonoperational.

If the only successful Malbolge program requires the cooperation of a human programmer and weak artificial intelligence, how can the computer’s functions be “real” in contrast to the “appearance” presented to the human programmer and user? Rather than showing that we humans have no control over our writing (and by extension our thoughts and ideas), the difficulty of the Malbolge programming means that humans have to acknowledge that the translation of inputs and outputs between the user interface and the machine code introduce new (non-human) readers and writers into the creative process. Readers and writers that use different conventions for communicating over different media. This conclusion could be read as supporting Kittler’s position that no so-called human subject exists and that therefore only the logic of technology matters. I would instead read it as Kittler putting too much emphasis on technology and computation. Where then do we put the emphasis? Do any of the new media code art pieces we’ve looked at this week help answer that question? Whatever our answers to those questions, I think that we would have to look at the dynamic exchange between human and digital computer.

Untitled #1: It made sense in my head

Filed under: Discussion — hbench @ 5:53 pm

Raley, Mateas, and Montfort approach code as both an aesthetic object as well as an executable object, or as Raley describes the difference, “code-as-text and code-as-operation” (3. Reading Code, n.p.). A critical aspect of code is, of course, that one cannot read code while it is being executed by a machine. Thus, when artists reconfigure code as literary objects, what they call out “is not the mechanism itself but a representation of the mechanism” (1. Code.surface|Code.depth, n.p.). In revealing the mechanism through its representation, they comment on code (or film in Raley’s opening example) as a mechanism of representation. By remaining within the apparatus of representation, however, the unmasking of codes is also a concealing of them, burying them under further layers of representation.

These additional layers, surface effects designed to accommodate human sensory relays, to return to Kittler, may shed some light on the wizardry taking place behind the curtains. Or, in the case of the weird languages Mateas and Montfort describe, they may further obfuscate seemingly simple operations with language play. What are the limits of code semantics for an audience of computers? of programmers? of laypersons? It seems that the permutations of language central to code aesthetics, whether in Caley, Mez, or weird languages, forces code to hover and vibrate between excess signification and indecipherability. They make language strange, revealing not the codes but the arbitrariness of codes.

Code thus produces far more than the screenic effects we expect. Code aesthetics hold perhaps once unforeseen consequences for so-called natural languages, and indeed, computational models for social analyses are nothing new. Mackenzie, however, suggests that code operates at a level that the other authors hint toward but do not address. He indicates the performativity of code not only at the level of its machinic execution, which Raley also discusses, but at the level of its social function.

The Linux kernel circulates in multiple versions and operates across platforms, recycling and citing itself with each successive iteration. Mackenzie thus turns to a performative model, collapsing performative utterances, in which speaking performs an action (I promise, I bet, etc.) with performative acts, wherein egos or identities congeal around their performances. Linux, Mackenzie argues, is performative because as code, it executes its statements, and as an object, it cites itself. But Mackenzie takes performativity a step further and suggests that the true output of Linux is not an operating system or whatever an operating system might enable. As a circulating cultural object, Linux produces a community of (male) programmers.

Notably, however, Mackenzie locates Linux’s origins in a clone of Unix, thus troubling the connection between Linux and the performative acts which constitute Linux. Performative acts have no identifiable source. Their function is to naturalize themselves through perpetual iteration. Layers and layers of performances cover the fact that there is no subject performing them—there is no original operating system, only the performance of codes.

Thus we return to Raley, but with a difference. No longer are we presented with “code-as-text and code-as-operation,” now we have codes performing as text and codes performing as operation. The question then is: “Can the codes performing as text shed some light on the codes performing as operation?”

hello world

Filed under: Discussion — johnbcarpenter @ 7:20 am
Tags: , , ,

 
//code is written in processing, for more info see
//http://www.processing.org 
 
//set the initial variables for the program
//initial text location
int textX = 50;
int textY = 50;

//initial text speed (X and Y)
int textSpeedX = 1;
int textSpeedY = 2;
 
void setup(){ /*void is a keword indicating a function
  setup–Called once when the program is started. 
  Used to define initial enviroment properties 
  such as screen size, background color, loading images, etc. 
  before the draw() begins executing. */
  size(200, 200);

}

void draw() {
  //load/setup the font
  PFont font; //PFont is the font class for Processing 
  font = loadFont(“Courier-14.vlw”);   //loadFont loads a font 
  //into a variable of type PFont
  textFont(font, 14);   //textFont sets the current font

  //create the trailing effect
  //fill(128);
  fill(128, 10);
  rect(-1, -1, width+1, height+1);

  //choose text color + draw text to the screen
  fill(255);
  text(“hello world”, textX, textY);

  //reverse text direction when it reaches the edge of the window
  if((textX >= (width-90)) || (textX <= 0)){
    textSpeedX = textSpeedX*(-1);
  } 
  if((textY >= height) || (textY <= 8)){
    textSpeedY = textSpeedY*(-1);
  } 

  //update the text location in the window
  textX = textX+textSpeedX;
  textY = textY+textSpeedY;
}
 

processing applet image capture               

Avatars, Fish, & Behavior

Filed under: Discussion — reneehudson @ 6:06 am

In this month’s Stanford Magazine, I came across the article “Seeing is Believing,” which explores the work of Jeremy Bailenson, an assistant professor of communication at Stanford. His current project deals with investigating the ways in which behaviors exhibited by people in virtual reality influence their real life behaviors. For instance, people who watch their avatars exercise tend to be more active than people who watch another person’s avatar exercise (52). These findings demonstrate that not only does virtual reality affect (at least short-term) one’s actions, but it can also be used as a tool to influence or change one’s behavior.

This topic seems related to our earlier discussion (which I hope we’ll continue to develop) on how the shift from print to digital culture will influence brain development. While we previously seemed to focus on the influence this would have on children, I think we should also think about how our digital experiences modify our behaviors as adults since changes in behavior will undoubtedly lead to changes in the brain (see Professor Fernald’s work on H. Burtoni fish, if you want a more in depth analysis of how behavior influences the brain). Bailenson does emphasize in the article that so far his group of researchers is only looking at short-term effects, but the implication is that there are potentially long-term ones as well. I realize that the issues I am raising do not correspond with our reading for this week, but I believe it’s an issue that we should continue to think about.

carrier: becoming symborg

Filed under: Discussion,New media art,Readings — Dr. Dave @ 3:25 am

My presentation tomorrow will focus on Melinda Rackham and and Damien Everett’s carrier: becoming symborg. Inspired by Rackham’s experience with Hepatitis C, this site generalizes the idea of code to include viruses and DNA, while exploring some of the same issues we have been talking about. I want to explore how the work plays into the following debates about code:

Surface and Depth: Is code a deep structure whose effects are only felt through the system rather than exposed by it? The work’s references to DNA suggests that in the case of the human body, we do not know what does our thinking, by which I mean the code of the human body are not directly visible to what it manifests (us). At the same time, on the message board, infection causes technical medical language to enter their conversation; the virus is felt by its effects, both in the body and in conversation.

On the technical side, while the work’s code is concealed, being written mostly in Java, Shockwave, and VRML, the proliferation of various languages brings them all to the forefront. On the original site, though, there is a “diagnosis” page, which helps users configure their browsers appropriately. The work begs us to look deep into its code. I’ve included the source code of some of the Java I find interesting here: infect.jar, fear.java, and DoubleHelix.java.

Execution vs. Surface, Cayley vs. Mez: Does the work’s use of the structures of the program’s execution as signifiers complicate our knowledge of code depth? Upon visiting the site, the browser downloads infect.jar. This simulation of the process of infection uses the system’s operation as a metaphor to make parallels between the computer and the body. This is a supposedly-hidden execution that the reader is meant to see, which complicates Cayley’s divide between machine and reader audiences. This is something seen in the structure of a language, not the actual code. Where does this fall on the Mez-Cayley spectrum?

The definition of code work: In addition to using the execution as a signifying structure, the work uses code-inflected English in a simplified Mezangelled aesthetic. Does this demonstrate how code begins to permeate language in a more subtle way? I’m thinking in particular of the lines “sHe extends [you]” and the punctuation on the Intimate screen, which allude to Java, but use the signs in different ways, showing how perhaps the presence of programming code frees us to use punctuation in novel ways, not necessarily those ways that are meaningful in the language.

The quote “sHe extends [name]” (a line in CarrierLingo) in Java, means “sHe is a type of object that builds on the functionality of the [name] object.” This line is targeted at the user rather than the system, asking us to imagine that sHe somehow takes a part of us and extends its own functionality that way. Interestingly, there is no sHe object in the source code. sHe is the (Infectious)agent that drives the program, but is the sum total effect of several other classes (see below), yet is experienced by us as a unified thing because we experience it as such. This questions the idea of there being a central signified driving the development of language and code.

Code as execution rather than artefact: Carrier suggests that life is defined by the activity of code copying rather than by an essential material, or meaning. The guiding agent, sHe, is made of Java classes that only contain parts of its behaviors; there are CarrierLingo, InfectiousAgent, and CarrierSite classes (in infect.jar), but no sHe class. A living creature (or an artificial one) is portrayed as the sum total of its actions rather than as an object. In the LifePoet nodes (fear and love), intent and order are contested by the placement of random text over Conway’s life (a process we can see is random in fear.java); activity takes the place of meaning.

January 27, 2008

code, performativity, Austin.

Filed under: Discussion — lindsaybrandon @ 8:17 pm
Tags: , , , ,

[I’m unaccountably nervous committing to blog-print. Here goes.]

I got a little excited about Adrian Mackenzie’s article—something with “performativity” in the title made me excited to have some context to bring to the table, since so much of what we’ve read and discussed thus far is so new to me.

My strongest impression is that perhaps one doesn’t have to make much of an argument for the performativity of code. I would be more surprised to see anyone argue against it—not only due to the breadth of topics and disciplines performance studies claims for itself generally, but because it seems undeniable that code is largely built for action. I suppose to the extent that code exists as an aesthetic object (like Rita’s description of the code in Talan Memmott’s work that exists as “a static linguistic and aesthetic artifact rather than as a functional program”) performativity might not be its primary characteristic, but even if we discuss it as an artifact rather than a piece of functionality, we might still talk about the work that it accomplishes in that state, about what the aesthetic object achieves or fails to deliver; its performance. At the risk of being reductive or simplistic, in my view, the performative lens is almost endlessly applicable (though certainly more useful in some contexts than others). Performance theory may often be deployed with more sophistication and specificity, but I think any time you’re discussing what something does rather than what it is, the performative is invoked.

Given that, I was intrigued by the move Mackenzie makes by anchoring his (her?) argument for performativity specifically in speech-act theory. It’s an interesting idea; if J.L. Austin’s point was that we can “do things with words,” doing them with and within the language of code seems like a logical extension. I’m curious, though, about what exactly is involved in treating spoken language and code as cognates, or even conflating them. There must be some slippage there, and I’m still pondering what might have . . . well, slipped. The move to speech-act theory is also interesting given that, although Austin may introduced the idea of performativity (or at least the term), to the extent that behavior itself is performance studies’ object-of-study, Austin isn’t specifically necessary in order to look at what code does. Mackenzie asks us to connect the technical performance of Linux to its performance as cultural object, presumably by way of speech-act theory; it seems to me they’re already inexorably connected, and that what would bear argument is the idea that we could somehow separate them. I’m not familiar with the work of Lee and LiPuma that Mackenzie cites (or at all, actually); I see how practices of circulation produce “performative effects,” although still I’m still mulling over Mackenzie’s implication that performativity requires objectification of social practice. Maybe I’m not sure what s/he means by objectification. I just hope it leaves room for the idea that performance—even of an OS—can be, in turn and even simultaneously, both normative and transformative.

(Has anyone read Jon Mackenzie’s book Perform or Else? From what I’ve heard, it seems like it might be germane to a discussion of how to work with performances of technology, but I’m still waiting on my recall of the library copy. If anyone has/has read it, I’d be interested in hearing how it jibes with this stuff.)

Week 4: more juicy syllabus goodness

Filed under: Admin,Readings — P.J. @ 12:51 am
Tags: , , , ,

For those of you wondering which “excerpts” from Cramer’s Word Made Flesh document we are expected to read, I got this message from Kate Hayles:

“As you will note, the text is quite long. Please treat is as a ‘browse’ selection and choose the section(s) that interest you the most.”

Be sure to get a clean plate before returning to the buffet line.

January 26, 2008

Lost but not for long: The Art of Me[ez]lang.elle.ing

Filed under: Admin,Readings — P.J. @ 10:50 pm
Tags: , , ,

The original link to the above listed in the syllabus directs to an expired site, but for reference I found what might be where the material has migrated.

The Art of Me[ez]lang.elle.ing

week 4: code websites

Filed under: Discussion — johnbcarpenter @ 9:27 pm
Tags: , , , ,


hi all,
i’ll be discussing processing (http://processing.org) in class on tuesday. i chose processing because it’s an incredibly fast and flexible software tool for visual designers + one of it’s creators (casey reas) is the head of the design | media arts program here at UCLA.

“processing relates software concepts to principles of visual form, motion, and interaction. it integrates a programming language, development environment, and teaching methodology into a unified system” (reas and fry, “processing”, 1). processing is an open source software / programming language that is based on java.

the websites i’ll be discussing on tuesday:

website 1
http://acg.media.mit.edu/people/fry/valence/

valence by ben fry

“the image on this page is taken from a visualization of the contents of the book “the innocents abroad” by mark twain. the program reads the book in a linear fashion, dynamically adding each word into three-dimensional space.”
more at… http://benfry.com/

website 2
http://reas.com/category.php?section=process

process 6 by reas, 2005

“text that defines a process”…
more at… http://reas.com/

January 24, 2008

Opaque Code and Code Movie

Filed under: Discussion — Dr. Dave @ 1:07 am

Something Prof. Raley said on Tuesday about the two kinds of code opacity made me rethink a work I’ve written on a bit: Code Movie 1, at the Electronic Literature Collection vol 1. This isn’t my link for next week; I’ll post that later.

I read this movie as making two statements. One: we perceive different file formats differently (a reading suggested by the author). Two: because the only access to a computer’s insides is through itself, is it possible ever to get a real picture of what happens inside from moment to moment? I’m curious if anyone agrees — particularly with my plot summary of the work, which follows:

An image is placed on a scanner. The “bars” of letters that sweep across it are the hardware inside a scanner that digitize it, represented digitally. The image becomes a set of information (represented by hex). It goes through more processes of storage, transformation, and maybe even editing, until it appears on the screen as a solid block at the end, where it is sent to the monitor to be displayed. The final fade-to-white represents that as we see an image (the white screen), or some information displayed digitally, the actual representation of it in code disappears.

My second reading is, I think, the most obvious one. What we see is only a collection of images of numbers that represent hex codes that represent voltage differences, and many different encodings of voltage differences at that — in RAM, on a hard drive, in the scanner cable, and on the screen. We can’t see into the depth of the system, only its representations of itself to us through its own executions.

The first is to me less obvious and bothers me a little more — the formats in which we store data do affect how we perceive the content. If you decompile the movie, you will find that each number is not just an image of a number, but an actual number stored as a character (the difference is between a JPEG of a six and the numeral 6 — you could extract the numbers from Code Movie and reconstruct the images algorithmically without too much trouble).

I find this second reading more chilling because it’s the author’s reading: Biegelman says in her artist’s statement: “Can we think in a poetics of transcodification between media and file formats?” I find this extremely antihumanist: though far be it from me to say that we can’t interpret this in other ways, what does poetics become when an author’s stated intent is to make a comment about how computers display data?

Next Page »

Create a free website or blog at WordPress.com.