Computer programming as performance

Suppose we apply the structure of composition → researsal → performance to computer programming? This has been a topic of conversation recently between Murphy Stein, Vi Hart and myself.

Currently, computer programming is generally thought of as a strictly compositional activity. A programmer generally creates a program in relative isolation, over a period of time, iterating until the program’s behavior is ready to be experienced by others. The programming languages and environments that have evolved to support this activity very much privilege this way of working.

But what if the semantic constructs of programming — sequences of variable assignment, iteration, conditional execution, defining procedures, building hierarchies of objects — were part of some sort of live performance for an audience?

Suppose we were to design a form of programming from the ground up, specifically to be a performative medium? It wouldn’t replace programming as composition, but rather would complement it. Much of the program would still be pre-written, as a compositional stage. In such a paradigm, one would also expect a rehearsal stage.

This splitting of computer programming into two such different modalities is not as odd as it might sound. After all, this is what happens with plays and music. While a playwright shares the medium of words — the semantic level — with the actor, their modes of expression are wildly different. The playwright expresses through typed or written words on paper, whereas the actor uses voice, facial expression and body movement. What they share is the underlying meaning.

Similarly, a musical composer writes down notes on a staff, whereas a musician plays a physical instrument. What they have in common is, again, the underlying meaning.

A kind of performative programming is done now in the avant guarde music community. Performers manipulate programs written in Max/MSP (or its open-source counterpart PD) to create live variations in the procedure controlling an algorithmically generated or modified composition.

Personally, I’ve never found the experience of attending such concerts to be entirely satisfying, since Max/MSP was never written for this purpose. Max/MSP programming on stage usually remains relatively opaque to the audience, even if audience members can see the computer screen.

It would be fun to design a programming language and environment specifically to be a medium for performance in front of an audience — with the understanding that much prior composition has already been done to scaffold what the audience is seeing.

A programming modality that privileges performance would be useful not just for music, but also for dance or theatre. One could imagine an evolving performance acted out by robot actors or dancers. As the performance progresses, the human performer modifies the procedural behavior of the actors. The audience experience consists not only of observing the actions of the robot actors or dancers, but also of understanding the rules those “performers” are following.

8 Responses to “Computer programming as performance”

  1. Tim says:

    Here is coding AS a music performance:
    http://vimeo.com/8732631
    (around ~2:30 it starts to get interesting…)

  2. admin says:

    That video is wonderful, yet it is also a good indication of the distance left to go. Unless you are really able to follow the Lisp (which most people are not) the connection between what he is typing and the music being created remains opaque.

    The tantalizing question remains: Is that opacity an inherent property of algorithmic description of music, or can we do better by rethinking the look and feel of a programming language from the ground up — with the specific purpose of live performance in mind?

  3. Sharon says:

    When I demo App Inventor I feel a little like I’m doing programming as performance, though the system wasn’t designed for performance per se. I am creating the program in front of the audience, and they are watching the composition as well as its effect (on the phone screen). I ended up doing some programming improv in the second session at the Faculty Summit in NY recently. After my planned demo, one of the audience members said “yes, but can it do XYZ?” so I proceeded to demo how to do XYZ, and then we modified it a little further interactively.

    I’m not sure this is quite what you meant by your post, though.

    Another mapping for the compose -> rehearse -> perform cycle in the programming world might be: write code -> test/dogfood -> run. This doesn’t seem as interesting, somehow.

  4. admin says:

    I always teach computer graphics and beginning Java by developing a program right before the class’s eyes, so students can see things come to life as they watch. The class always enjoys it, although in the beginning class some students seem intimidated.

    But as you point out, neither Java nor App Inventor nor Lisp are designed for performance — the audience is not entertained by the code itself, and I doubt most people would pay for an evening’s entertainment watching somebody program in these languages.

    I think the issue lies with the separation between code and behavior — the code remains merely a lexical expression of its semantics. A language in which the code “acted out” its meaning might be more effective as a programming language for live performance.

  5. Sharon says:

    Why do you want to make the composition phase be part of the performance? Is the goal to give the audience insight into the creative process? Do you think the creative process will be entertaining in itself? Are you trying to draw the audience in as co-creators? I think the answer to this question shapes the discussion. In the arts the creation of the piece usually isn’t part of the performance, as I think you pointed out. There are exceptions, like street artists creating sidewalk “murals” at fairs and probably other, more sophisticated examples, but I think they are the exception. Even with improv, we see the creator at work, but we don’t necessarily get insight into the processes they are using to create on the fly.

    It might be interesting to look at how films have portrayed the creator at work. There’s an example of trying to show the creative act in a way that is entertaining or informative. How true are they to the actual creative process?What means do they employ to keep the audience engaged? What are the best examples of programming being portrayed in films?

  6. admin says:

    It’s not so much that the composition is part of the performance, but rather that we are talking about distinct creative acts.

    The creative act I’m focusing on is “the creative act of effective interpretation” — what an actor does in conveying a scene from “Hamlet”, or a musician does when playing a passage by Bach. In the case of drama or dance or music performance this creative process of interpretation is relatively transparent, in that the audience familiar with the work of Shakespeare or Bach can see exactly what the interpretive artist is adding to the experience. The interpretation, in its own right, is an enjoyable process to witness.

    If we are to think of a performing artist interpreting a composition to an audience through some sort of programming-like expression — I realize this is a big “if” — then I’m trying to see whether an equivalent level of transparency could be achieved, in a way that is similarly enjoyable to an audience.

  7. Sharon says:

    Hmm, let’s see if I get it now. So you could imagine, for example, your fish character’s interpretation of a set of rules, vs. the Luxo Jr.’s interpretation of the same rules? And would the audience need to see a representation of the rules to get that they are the same and appreciate the interpretation?

  8. […] an earlier post on Computer Programming as Performance, I raised the possibility of writing computer software as an act of performance in front of a live […]

Leave a Reply