{As Critical Code Studies amps up for the academic year, Im beginning a series of posts on the foundations of critical code studies. Prepare for more frequent posts, new members to the CCS blog, and a high level of CCS Tweeting > Ill report back on the Hashtags. Come and play!}
In computer science a metaphorical hierarchy describes how much natural language is in a particular programming language. If the language is different or from machine language, as in those relatively close to natural English, such as Inform 7 or even Basic, the language is considered high level. Natural language is abstracted from, or layered on top of, the machine instructions. At the lowest programming level [or is binary the lowest] is machine language. This language is not abstracted from the code instruction set architecture and does not need to be compiled. Imagine a ladder that runs from the hardware all the way up to we muddle-speaking humans (well shake up this ladder later).
Its safe to say programs in higher level languages are easier (for interdisciplinary Humanities types) to interpret.
Machine language programs can be interpreted, especially since they implement the same processes that the high-level language describe. However, the human-computer interaction happens at the level of the language the computer programmer is using, or more accurately at the level of the electronic impulses those languages represent. So while the machine language may be considered more pure, closer to what is being processed by the machine, what I seek when I do CCS is that language that the programmer is wrestling with. Again, in spoken language, there may be neurological impulses or sonic vibrations that represent what any given person actually processes, but the study of literature busies itself with the speakers engagement with the semiotic system quite a few levels removed.
Nonetheless, Critical Code Studies would be a very poor endeavor if it forbade the interpretation of any level of the code. My note here is just that it seems to become not only more difficult to interpret, the lower the level of the language, but also that lower level languages can offer fewer handles for Humanities scholars to grab.
At this point, the question arises, how high level does code have to be before it can be interpreted? At what point does Critical Code Studies turn into algebra or lambda calculus studies? When does the work become more like decryption than interpretation? In other words, when does the code itself become an object less rich for study.
Again, in light of cultural studies, where all artifacts are texts, and in a field where critics can equally interpret the platform of the Atari 2600 and the material of the hard drive, it would be foolish and self-destructive to rule out any objects of study. This meditation is more me looking for the code objects that might be easiest to begin with.
Clearly it is easy to make a Humanities-style comment about the meaning of a natural language variable, for example a variable called victim in a program that calculates automobile insurance claims. However, variable names are rather soft targets because they are the most arbitrary of elements. In other words, there is little in the programing language to constrain them and victim could just as easily be 192sf12.
Admittedly high level languages share a similar arbitrary character. Print could just as easily be inscribe or alter or askd123 for that matter. In fact, encryption algorithms produce just that transformation. Outside of the limitations of the architecture, computer languages have wide-ranging arbitrary character. However, unlike computer variables, natural-language words used in instructions in programming languages create the conditions of coding practice and become the langue, the formalized rules of communication. In this way, the selection of print for display in any particular programming language means that every program written in that language will have to use the word print (or the string print) to execute that function. That systematic aspect of instructions makes them something more than arbitrary choices, they become formal linguistic elements that take on meaning within the culture of programmers which they produce.