Patrick Burgaud

Patrick Henri Burgaud was born in 1947. In 1992, he left education to devote all his time to artistic practice — monumental poetry, land art, visual poetry — his early work focuses on the visual impact of the alphabet.

In 1996 he discovered the potential of data processing. Computer generated poetry opened up a new dimension in his work. Since then, as technology developed, his his research has turned to programmed art, interactivity and net art.
Site: http://www.aquoisarime.net

Greg Elmer

Greg Elmer is the Director of Infoscape Research Lab. He is the Bell Globemedia Research Chair, Ryerson University. He is also a Columnist at The Hill Times.

Elizabeth Swanstrom

Elizabeth Swanstrom is a doctoral candidate in Comparative Literature at the University of California, Santa Barbara. Her interests include literature, digital culture, the history of science, and media theory. She is currently working on “(Me)diation: Network Technology and Emergent Selfhood,” a dissertation which examines the relation between network technologies and subjectivity in 20th and 21st century expression. Home page: http://www.swanstream.org/

Why not work out a theory of video game narrative using the logic and idiom of the object-oriented programming languages that are used to create the video games in the first place?

Sounds like a job for Critical Code Studies.

It remains to be seen to what degree Noah will dig into code. While this germ of an idea would certainly fit CCS, more curious is who has posted the challenge. It’s none other than the notorious Luthe Blisset.

Luthe Blisset, or more properly, Luther Blisset is, how should we say, an open source mask, or better — a creative commons alter ego that’s been around since 1994.

Members of the Luther Blisset Project, Eva and Franco Mattes, “a couple of restless con-artists who use non conventional communication tactics,” have gone on to form 0100101110101101.org. One of their projects also invites and informs CCS.

Consider their Biennale.py, a computer virus work of art. They describe the work:

Biennale.py is the first computer virus ever written employing the Python programming language, and one of the few, if not the only one, whose name is written at the same time in the Computer Science and Art History books. The virus stresses its “aesthetic qualities” through the beauty of its own source code, a “love poem” being an integral part of its executing code. «We’ve chosen Python - says Massimo, Epidemic spokesman - exactly for the possibility to give any name to the variables, in practice you can write software with your own words».

This concept of writing software “with your own words” raises many questions with respect to higher level languages as well.

Consider (at your own risk) this excerpt from Biennale.py source code:

def fornicate(guest):
try:
soul = open (guest, “r”)
body = soul.read()
soul.close()
if find(body, “[epidemiC]”)==-w:
soul = open(guest,”w”)
soul.write(mybody + “\n\n” + body)
soul.close()
except IOERROR: pass

Here is virus code as codework inviting and enacting critical play with code.

Also, on the Valve, Bill Benzon has an interesting, if somewhat skeptical, post about CCS. To better consider the tenets of CCS, Benzon has brought the matter to the League of Extraordinary Coders:

I sent the email to some friends in the software business and one of them, Richard Fritzson, pointed me to the Wikipedia entry on Conway’s Law:

Conway’s Law is an adage named after computer programmer Melvin Conway, who introduced the idea in 1968. It concerns the structure of organizations and the corresponding structure of systems (particularly computer software) designed by those organizations. In various versions, Conway’s Law states:

* Organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.

* If you have four groups working on a compiler, you’ll get a 4-pass compiler.

Or more concisely:

* Any piece of software reflects the organizational structure that produced it.

Benzon’s critique here captures at least one aspect of critical code studies, the reflective aspect of code; however, it omits (among other points) the way in which code (and its execution) inform and shape culture. This relationship is more than just a one-way impression: the code is a particular kind of semiotic element that enters and transforms systems of culture as language that (might) execute.

The Biannale.py source code art piece raises the spectre of another level of significance in code in the context of programs that one might look at from a far but never implement.

15($stiff . ening with fea((c))r(eam)!)
5($limb . less f((l))ailings)
53($swelt . (i)ered.fractures
35($uglin((dr))ess(es) (x)
30($denied . (see)d(s)ire
331($snipped-genital-(pup(a))pets x))))))
object
33($rot-cavity-m(f)o((a)rm)ldings)
3($(flesh . g)r(e)ying . orGa(mete)n(Elles))
13($let ((form))
13($get* bindings . b(lind)ody))

($define! force-promise
clammered
($if (not?
clammering
object
(handle-promise-result x)))
hammered
($define! handle-promise-result
amber
($gene (x y)
chambered
((not? (promise? y))
(iambic.pent((up))a)meter
(set-(h)eart(h)! (var x) y) ;
(set-earth! (var x) ()) ; delete y)

exact?, inexact?, robust?, undefined?
get-real-internal-bounds, get-real-exact-bounds
get-real-internal-primary, get-real-exact-primary
make-inexact
real->inexact, real->exact
with-strict-arithmetic, get-strict-arithmetic?

numerator, denominator
floor, ceiling, truncate, round
rationalize, simplest-rationa

make-rectangular, real-part, imag-part
make-polar, magnitude, angle

–

_________________________________
#dn[p]a[per.cut here.]bird#
06:07pm 30/01/2008
_________________________________
BirdF1-TTCTCCAACCACAAAGACATTGGCAC
BirdR1-ACGTGGGAGATAATTCCAAATCCTG
BirdR1-ACGTGGGAGATAATTCCAAATCCTG
BirdR3-AGGAGTTTGCTAGTACGATGCC
BirdF1-TTCTCCAACCACAAAGACATTGGCAC
BirdR1-ACGTGGGAGATAATTCCAAATCCTG
BirdR1-ACGTGGGAGATAATTCCAAATCCTG
BirdR3-AGGAGTTTGCTAGTACGATGCC
TTCTCCA#cut[icle].bird.ACCACAAAG
ACGTGGG#line.here#AGATAATTCCAAAT
ACGTGGG#fe[e]tally.blind#AGATAAT
AGGAGTT#cur[e]ve.d.h.orn[er]y.TGCT
AGGAGTT#bill.on.my.GCTAGTACGATGCC
ACGTGGG#pro[ad]verbial.tab#AGATA

One of our projects here at CCS will be to mention books that contribute to Critical Code Studies (adding them to our LibraryThing account). Scott Rosenberg’s Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software offers some strong material history and reflection on development of a specific and open source piece of software, Mitch Kapor’s Chandlor. It gives a glimpse at the shear amount of human and machine activity and conflict surrounding the production of working code, all of which can inform CCS readings.

An excerpt offers one of the already typical moves of CCS, to perform a reading of a “Hello, World” program, especially in a comparative context. Nick Montfort, Michael Mateas, Beth Coleman, and I (among others) have already offered “Hello, World” readings.

A novice programmer’s first assignment in a new language, typically, is to write a routine known as “Hello World” — a bit of code that successfully conjures the computer’s voice and orders it to greet its master by typing those words. In Basic, the simple language of my Sumer game, it looks like this:

10 PRINT “HELLO WORLD!”
20 STOP

“Hello World” programs are useless but cheerful exercises in ventriloquism; they encourage beginners and speak to the optimist in every programmer. If I can get it to talk to me, I can get it to do anything! The Association for Computing Machinery, which is the ABA or AMA of the computer profession, maintains a Web page that lists versions of “Hello World” in nearly two hundred different languages. It’s a Rosetta stone for program code.

“Hello World” looks more forbidding in Java, one of the workhorse programming languages in today’s business world:

class HelloWorld {
public static void main (String args[]){
System.out.println(”Hello World!”);
}
}

Public static void: gazillions of chunks of program code written in Java include that cryptic sequence. The words carry specific technical meaning. But I’ve always heard them as a bit of machine poetry, evoking the desolate limbo where software projects that begin with high spirits too often end up.

Rosenberg passes quickly over the reading of “Public Static Void” a line that has even earned its place in the Urban Dictionary.

It is a favorite line to complain about. Complaints range from the problem the line reflects in Java.

Basically, the break down (cobbled together from various online texts)
public – “other objects can access this classes data or access the method from outside the class”
static– “theres only one copy of the thing your declaring static in memory and you don’t need to create an instance of the class”
void– “it returns nothing”

(this clearest explanation was posted here: in yet another discussion about just why this line of code is necessary.)

Note this line of discussion of the code on the Sun Developer Network:

uj_ :The static main basically is a mistake. It just confuses newbies and they tend to write programs with static variables & methods only.

>CeciNEstPasUnProgrammeur : Very good point. Doesn’t really help much, though, because they’ll still write illegible code. I prefer readable newbie code to un-OO newbie code… though I like your suggestion, it’s just a drop in the ocean.
Teachers need to give more education on OO design and coding style.

>uj_ : Yes static is a keyword you really shouldn’t care much about at first so it’s a pity newbies have to deal with it when they write their very first line of Java.

Rosenberg however is doing a bit a Critical Code Studies by calling our attention to the evocations of those words strung together to evoke the void created in the public through the static of unfinished software. The words play off well the context of a “public” of newbies, the “static” or “public static” of disagreement over the need for the line itself, and the sense that its usefulness is “void.” Rosenberg folds this reading nicely into his larger discussion of software.

Although Rosenberg doesn’t spelll out his reading, his gesture toward this specific line of code has a lot of CCS heft in it.

CCS Bloggers (see their bios here)

* Christian U Andersen
* Sandy Baldwin
* Gregory Bringman
* Patrick Burgaud
* Wendy Hui Kyong Chun
* Christy Dena
* Jeremy Douglass
* Aden Evens
* Daniel Howe
* Mark Marino
* Mez
* Wayne Miller
* David Parry
* Rita Raley
* Amit Ray
* Braxton Soderman
* Paul Swartz