(link to code here) (updated final)

Actual coded Sol Lewitt drawing (unfinished, but still cool!) by twitter user @zeffii, with whom I exchanged a couple of tweets as a result of Golan’s tweet from last night… Just thought it would be interesting to share.

It was fun, everybody was reading again and again the instructions, made some notes on the paper. “what, a point half between a point half between a point…”. Stefan is convinced syntax of the first point is wrong, “please, ask Golan”. Hmm, I’m not sure I trust Stefan he is a postdoc at the CMU and does some insane calculations for robotics.

For me the first point was a pain in the as, but the second point, I got it. I was happy, I felt that I could decode Lewitt’s code. Sure that instruction was a code, more a poetic one than machine readable code. Every time converting information with a set of rules into another piece of information we can speak about a piece of code. Knitting patterns, the recipe for German sourdough bread and the score of the 9th symphony, these are all codes.

My attempt:

 

Reading the instructions for the first couple of times were very frustrating, until I realized there was supposed to be parenthesis around certain phrases, so I retyped the instructions with parenthesis. For instructions for each line, I made reference dots from the innermost parenthesis first, then worked my way outward. I also found the “axis” part confusing, and opted to ignore it (yikes) and went with intersecting point of lines as with all the other parts of the instruction. If this was code, the computer would have threw a fit from the parsing errors already.

Students, I thought you might be interested in the results of our Lewitt Wall Drawing assignment from Assignment 02.

You were asked to execute a Sol Lewitt wall drawing, as many gallery assistants have done before you:

I now present to you Lewitt’s “original” solution from 1974, below. His image and his text (“code”) are both reproduced from “Logical Conclusions: 40 Years of Rule Based Art“, an exhibition catalogue published by Pace Gallery, New York in 2005.

I did some ‘shopping to align your various solutions, compensating for variations in position, size, rotations, and (in one or two cases) some minor quadrilateral warping. Here are all of your solutions aligned and overlaid:

As you can see, there is considerable variation. Another way to view this is over time. Here’s an animated GIF of your solutions; Lewitt’s version has been labeled and has a 3-second pause:

Of the 13 solutions you posted by 10pm, only one was ‘correct’, matching the published drawing: Melanie Kim’s. Here you can see her version overlaid against Lewitt’s. She correctly parsed his code (which you can confirm from her guidelines), and her execution is correct to within the precision of her ‘output system’.

If I were Pace Gallery, I know whom I would hire. 

(Miles and Michelle also came close. Miles got the bottom two points correct, while Michelle got the top two. Michelle has asserted that the statement, as it appears in the Pace catalogue, only makes sense when an additional phrase is added. In any case, each of the corners of Lewitt’s quadrilateral was reliably located by about a quarter of the students.)

Incidentally, I would like to bring attention to the marvelous pseudocode system that Melanie developed for parsing Lewitt’s statement. (Others of you did something similar: notably Julia, Chloe and Miles.) As far as I’m concerned, Melanie has earned the right to title her pseudocode as she did. This document is really a gem: through its indentation and other typographic cues, Melanie presents a visualization of the structure of Lewitt’s work which is not otherwise available in either of the versions officially published by Pace.

 

OuchMyEyesMyBrain.

C̶o̶d̶e̶.̶ ̶L̶e̶w̶i̶t̶t̶’̶s̶ ̶i̶n̶s̶t̶r̶u̶c̶t̶i̶o̶n̶s̶ ̶l̶e̶a̶v̶e̶ ̶n̶o̶ ̶r̶o̶o̶m̶ ̶f̶o̶r̶ ̶i̶n̶t̶e̶r̶p̶r̶e̶t̶a̶t̶i̶o̶n̶.̶ ̶W̶h̶i̶l̶e̶ ̶b̶e̶i̶n̶g̶ ̶e̶x̶t̶r̶e̶m̶e̶l̶y̶ ̶h̶a̶r̶d̶ ̶t̶o̶ ̶u̶n̶d̶e̶r̶s̶t̶a̶n̶d̶,̶ ̶o̶n̶c̶e̶ ̶t̶h̶e̶ ̶m̶e̶a̶n̶i̶n̶g̶ ̶i̶s̶ ̶e̶x̶t̶r̶a̶c̶t̶e̶d̶ ̶t̶h̶e̶r̶e̶ ̶i̶s̶ ̶a̶n̶ ̶o̶b̶j̶e̶c̶t̶i̶v̶i̶t̶y̶ ̶i̶n̶ ̶h̶i̶s̶ ̶i̶n̶s̶t̶r̶u̶c̶t̶i̶o̶n̶s̶.̶

I take back everything that I said previously. It was written pre Golan’s post, when I had (proudly) thought that I had conquered the piece. Lewitt’s instructions are definitely code. Code not fit for human consumption. While the instructions do have an objective truth to them, we humans are not built to decipher and follow such things. The world needs to be more human. I appreciate the importance of proper syntax when coding. This also re-enforced my dislike for the instruction manuals that come with consumer electronics. They are written in a similar manner to Sol’s instructions.

Reminded me of a segment of John Maeda’s talk (watch from 11m 55s )  –

 

Drawing this was frustrating. Or, if frustration is too strong a word, then perhaps my senses were dominated by irritation that rendering this drawing is arduous and repetitive yet somehow still challenging. In fact, this brings me right down to the reason we write code. We invented computers to do long, boring calculations for us, and to do them faster than we ever could. We invented them to be accurate and to eliminate human error. This was more evident than ever when trying to execute Sol LeWitt’s “code”: one could choose to either act like Python and try to execute each instruction or set of instructions as they were encountered, or one could try to put brackets around the various sets of instructions to try and make sense of them. I am sure I made a mistake, as it is very easy to do. On the other hand, I am sure that for this particular piece there is “correct” way to complete it. The instructions were very precise, measurements were proportionally exact, and the only room for error was human error. Again, I find this frustration, and again, this is why we use computers. “Quadrangle” could well be a code but lacks a compiler able to run it methodically, and as humans fail to fit into such a category, the code is for all intents and purposes useless (unless the purpose is conceptual, as in to point out how humans differ in terms of thinking style etc.). This is the beauty of programming: a compiler will produce consistent, reliable results with preprogrammed outcomes. As humans, thinking different ways and finding different interpretations is enjoyable – and this is why we invented machines.

Drawing Lewitt’s quadrangle was a struggle. After reading and rereading the instructions, I ended up typing them out word for word in a text editor, then breaking them up using operator words (“a point halfway between”, “and”, etc.) and indentation/whitespace. That alone wasn’t enough; in the end, I needed a more succinct way to represent any point on the screen, so I created a grid ranging from (-2, -2) to (2, 2) and started referring to points that way. That helped immensely (hence the title of this post.)

Lewitt’s drawing instructions are code, I think, strange as it is. It is a code using English syntax rather than that the syntax of a programming language, but it is precisely describing a set of actions to execute in a very code-like way. That said, one long English sentence is not a nice coding language to work with. Turning it into pseudocode seemed to be the only way to deal with it. I guess that’s an interesting part; to execute code, as a human, I have to turn it into pseudocode (higher level), while a computer would have to translate something lower level.

Sol Lewitt’s Wall Drawing was quite an experience. While the curiosity of what the shape would look like was a great driving factor, it could not trump the frustration that came with having to keep track of my progress through the guide given. I found myself having to open up a word document breaking down his instructions bullet point by bullet point, parsing things into sizeable more logical chunks. I also had to clear out the sentences from the original instructions as I progressed in order to not be confused about which ‘points’, ‘halfways’ and ‘midpoints’ I was drawing. Maybe it’s just me taking on the role of a program trying to follow exactly what the rule tells me, following it in the order with which its presented.

In essence, the Wall Drawing can be considered a form of code, albeit one that is not so elegantly formatted for efficiency both on the part of its execution, and for the review of the user.

This experience was pretty awful. I’m really bad at following both spoken and written directions and have a difficult time parsing meaning in really long sentences. I actually made a first attempt and failed miserably at it because I couldn’t focus past the third line. So I scrapped it when the third line refused to make even the tiniest bit of sense, and started anew. Maryyann and Ralph gave me some pointers about missing “between”‘s and extra “to”‘s, so that was immensely helpful (those are the ones that gave me the most headaches). I ended up writing sort of a pseudo-code in the text editor Sublime Text, which aided me greatly.

So, this is code, but not the code we’re familiar with. The code we’re familiar with has syntax. It has indentations and logical structure. Sol Lewitt’s instruction does not, yet it is code because the instruction is what happens when style rules are broken at every given point. It is completely unintelligible unless you deconstruct the entire paragraph, or rather, the entire program. That’s the case for humans; for machines, it makes no difference if a line is indented or spaced out for readability. I recall a lesson in a CS class: we write code for humans to read.

I remember now why I don’t write code in a single line even though it’s possible to do so in certain languages: because of the horrors like Sol Lewitt.

On first reading the Sol Lewitt’s “Wall Drawing”, I felt totally overwhelmed. Although it was clear to me that the instructions were precise, I found them excruciating to parse mainly because of the nested structures littered throughout the text. To remedy this difficulty, I broke the text down by isolating the instructions for each point (the instructions for any two points were separated by the word “to”). I then transferred these instructions to a table, and organized them by line number (1, 2, 3, or 4) and by point number (p1, p2). Within a given instruction, I found instances of nested points (halfway between a point halfway between) and color coded them for readability.

I eventually generated a quadrangle from the instructions, but was not satisfied by the results. Particularly, I was unsettled by the ambiguity of this instruction:

A point where a line would cross the first line if it were drawn from the midpoint of the right side

This instruction, I found, allowed for an infinite number of points along a certain line. To be sure, Lewitt might have intentionally embedded ambiguity to allow for variation and an element of interpretation. And yet, this particular instruction stood in stark contrast to the specificity of the other instructions, all of which referred to a single point.