Howdy, Stranger!
It looks like you're new here. If you want to get involved, click one of these buttons!
Categories
In this Discussion
Week 2: Creative and Critical Coding (Main thread)
Creative and Critical Coding
by Margaret Rhee, John P. Bell, and Evan Buswell
feat. code from Ben Grosser
Key threads:
- Coding as Method?
- Calvinball and Coders
- Poetry as Code? Code as Poetry
- Rando by Ben Grosser (Code Critique)
We are three people who write code, in one capacity or another: Margaret Rhee, John P. Bell, and Evan Buswell. Each of us brings a different approach to coding, and code has a different relationship to each of our works. We’d like to bring out those different approaches, but also to hear from everyone else in the working group about how they code, or how they think differently about coding because of their critical approach.
We’ll each be making an individual presentation today (Monday), Tuesday, and Wednesday. So stay tuned! As a bonus, we will also have a featured code critique on Go Rando from Ben Grosser!
Below, we have a list of provocations and questions to consider throughout the week. Feel free to post in this thread anything that has to do with these questions, or with critical or creative coding more broadly.
Provocations
- The humanities is increasingly focusing on making and doing, to supplement its previous focuses on understanding and interpreting.
- Critically writing code is the other side of critically reading code, and we want to foster a healthy relationship between these two approaches to code and coding.
- How is code poetry? How is poetry code?
- Do we build bridges across code approaches?
- Where does utility end and play begin? Can you use the same critical framework to think about both independently?
- What is the relationship between Critical Code Studies and writing code?
Comments
This is my favourite discuss.
A very interesting thread, where the focus puts more on writing (apparently) than reading, and this weaves in code poetry/code work quite nicely. To what extend code poetry conflates with computation and critical writing, and how critical writing has emerged with computation? Which aspect of of critical thinking has been promoted via code poetry, which is different from poetry? Look forward to the discussion
I am excited to hear, you will discuss code poetry.
Great set of questions! I've been writing lots of critical articles for tenure, so I've been away from these questions for a little while, but I've produced a couple of creative works. I'm currently editing an issue of ENCULTURATIONS with Helen Burgess on "Critical Making and Executable Kits," which is a sequel of sorts to her HYPERRHIZ issue.
One of my favorite arguments to use whenever the question of the critical work of creative pieces is Gregory Ulmer's HEURETICS, in which the pertinent question is not limited to the hermenetutical one, or "what might be the meaning of an existing work;" but is instead also concerned with scholarship as a heuretical "generative experiment: Based on a given theory, how might another text be composed?" (5).
That is, critical theory can give us methods for understanding and interrogating different kinds of creative processes. IMHO, this approach also connects to the work Burgess and other people in electronic literature operate: i.e. how, in SCALAR, the work of Tara McPherson and @craigdietrich is designed around and reacting to feminist film theory.
McPherson and Dietrich aren't students of Ulmer, but I find it fascinating that so many of Ulmer's students are in fact in rhetoric and composition - b/c Heuretics acts as one potential bridge illuminating interconnections between electronic literature, critical making, and digital rhetorics. (And I'll go ahead and admit that not all of Ulmer's work is useful to me, but that this particular issue is enormously useful, in my view).
I also think another potential field to consider is design: i.e. the work of Carl DiSalvo on "Adversarial Design" and Benjamin Bratton's work on THE STACK. In each of these accounts, we get a depiction of design as thoroughly political and critical. So, for me, the question about art isn't whether or not it is "useful," but to what degree it engages in and is mindful of the political and social contradictions it inhabits. I think it would be useful to also consider it in terms of ecology - i.e. of what is it made up?
Thanks for starting this thread. I'm already excited!
I'm drawn to the 5th provocation, considering the interplay (!) between play and utility. The topic resonates for me in at least a few respects:
As a 1st-timer CCSWG participant, I'm eagerly anticipating the conversation!
Appreciate all the enthusiasm!
Interesting! I'll have to look at it.
Generally speaking, it's entirely possible that the answers to many of these questions/provocations are already out there, so bibliography-building is a great activity for this thread.
For me as well. Although my questions—and I think my co-presenters may diverge from me a little here, so that's why there's three of us
—my questions are not so much about judging the work itself, as they are about judging the relevance of the work to academic work. Like, there are many ways of talking about art/craft. But if one is making art/craft as part of one's academic work, what does that mean? If I'm writing code as part of doing critical code studies, what does that mean? The academic side of things is (politically and otherwise) responsible for caring for truth, for lack of a less loaded word. But it's unclear how this kind of actual production contributes to that responsibility. (This maybe more properly belongs in the other thread.)
This brings to mind some the projects from the School for Poetic Computation, which fosters some super-interesting work in NYC: http://sfpc.io/
In particular, I've been following some of the projects of the artist/instructor at SPC named Taeyoon Choi. I thought his project on errantic poetry might be relevant:
http://taeyoonchoi.com/category/artworks/
This seems like a rich question, because there are many potentially useful syllogisms at hand, any one of which might only be a partial fit:
The "critical" in the name Critical Code Studies seems to signal some specific things about hermeneutic interpretation (and perhaps cultural studies). In addition, code is often read in many ways, but "studies" further implies "this is not your typical reading."
In practice Critical Code Studies may be about studious critique, but it may also be much broader: a larger community of all kinds of approaches to software. One of the interesting questions that creative coding raises for me is whether this enlarged conceptions of CCS could be circumscribed as "a group of reading-centric approaches to software," with creative code is the object (or byproduct) of multiple kinds of attention.... or, if writing-centric or mixed methodologies should also be part of our core concept of what it means for CCS to relate to consider code, critically.
On the one hand, creative coding might be the radical outlier -- like feminist fictocriticism. On the other hand, in the context of code culture at large it can already be radically surprising when CCS focuses on code reading -- or even giving equal weight to code reading over code writing.
This might be because the implied reader of a piece of code is often a code writer or editor. Throughout coding conventions in many languages we re-encounter the practical assumption that, if code is being read at all, then it is probably being read in order to be incorporated into newer code, or to be corrected, updated, extended, refactored, et cetera -- code reading in service of immanent code writing.
This has often not been the case in Critical Code Studies. Instead, just as most Art Historians do not paint about art, for many code critiques code reading has been followed by prose writing. Does this make CCS more like the act of writing software documentation than writing a library? Or might it mean that there are many forms of writing about code -- including many forms of code-about-code -- that we have yet to fully explore?
@jeremydouglass, this is the same question I ask myself. Must I know how to code or write code before I can participate in CCS scholarship?
I think this is really important, because Art Historians and Art Critics are great examples of a different paradigm of interpretation/production than we see discussed in CCS, DH, and STS. Art Critics and Historians are not really art "producers," and yet they are considered a vital part of what constitutes the cultural (and, sigh, business) production of artwork. This is Becker's "Art Worlds" analysis. While artists, art historians, and art critics all practice different kinds of knowledge-making, they are also all a part of a mutually constitutive creative apparatus. This is (generally) mutually understood among artists and critics.
So, for me, the problem isn't one of writing "documentation" vs. writing "code." It's "why aren't documentation, critique, code, and interpretive practice all considered part of the same apparatus?" Let's use CCS to build Code Worlds.
I find this all fascinating. There was a time, early on in CCS, when I said that one does not even have to be able to program to "do" CCS. I remember Stephen Ramsay in particular took issue with that claim. Of course, Stephen would then throw the bomb at the MLA, asking for "more hacking, less yacking." And here we are now in the era of critical making.
Since those early days so much creative scholarship has taught me lessons on both sides and especially never to exclude or underestimate an approach, especially if it is not my approach. Take coding to critique: The person who lives in code, like the person speaking their native tongue, understands what can be said and what cannot at a level of intuition. If they have been programming for some time, they have absorbed not just coding conventions, but they have often become acculturated to one programming culture or religion or another, paradigms, approaches, languages, architectures, design principles. That acculturation comes with the insight of experience, perhaps also bias, a cultural perspective, but also a knowledge of systems of the challenges of making. The non-coder brings these as well. As we discussed in Week 1, there is a value to creating collaborative exploratory environments full of many points of view, a community whose variety of experiences leads to expanded knowledge.
@jeremydouglass said:
I love this notion of "studies." I've seen Jeremy's form of wildly creative, mind-blowingly inventive studying. He is an arch-teacher in this robust sense of study -- as drawing upon multiple approaches. And indeed it was a sense we brought to our "project" of reading electronic literature in Reading Project. We are in a moment that is embracing multiplicities of reading and studying practices or critical praxis.
Studying code through making code has proved to be such a valuable part of what we do. When we were writing 10 PRINT, Michael Mateas and @belljo wrote programs to gain insight into that program. Back in CCSWG 2012, @DavidBerry wrote hello worlds in a variety of esoteric languages. He ported one of Ramsay's works, a Shakespeare insult generator, into another language. Porting and translating programs is a productive form of writing that I have enjoyed as well. It asks, "What is this program doing?" and "Why?" and how does the program's expression impact its meaning? There's been even a recent run of people re-implementing 10 PRINT. This is rich knowledge production, akin to and yet different than the work of the translator, the curator, the mechanic, the impersonator.
However, as one who came at this with minimal programming experience and still feel like a perpetual newbie, I appreciate the perspective of the newcomer to a language. The student of the romance language who asks, why do we have gender in our nouns, what difference does it make, why is a chair female? What does gender even mean in a language (or otherwise)? Similarly, I find myself asking people about their assumptions: why is that code laughable, why do you think object oriented or functional programming is better than imperative? Sometimes the answer is technical. Often it is more a product of history and convention.
There is no doubt also the person who lives in between, who is creating through their code switching. Who tries to make a language do something it is not ready to do, who lives on the border. There is much creative insight in the person who lives in a state of mixed literacies or iteracies as @DavidBerry has formulated.
The foreigner asks about assumptions, questions conventions. But it is when we go to speak that we gain I kind of knowledge of the challenges, limitations, possibilities that are harder to appreciate "academically." And there is not one code literacy either. I'm thinking of the way "old timers" complain of new programmer who don't recognize the importance of trash collection. It's more than just saying, "In my day, we had to go out and pick up the newspaper from the sidewalk."
In this week of Creative and Critical Making though, it is refreshing to reflect on what making has to offer our studies. And this has lessons for lots of aesthetic pursuits. As someone who tries to create literature and to study it, I appreciate the insight of making in non-computational realms as well. If you've ever learned to carve wood or to cook, you appreciate woodwork and cooking differently.
I would say, @Waliya, no you don't need to produce code to study it, but contribute to the insights of those who do, your unique insights as someone who can do so many other things.
@malazj said:
Yes, let's!
And also picking up on the provocation from Buswell re the humanities turning toward making and doing. As someone that comes to Critical Code Studies from design research, rather than the humanities, I am also looking for a way to bring the writing of code together with the reading of code. I would like to ask whether people engaged in CCS, who also write code as part of their practice, feel that they write code that is reflexively informed by their interpretive methods? I find this very difficult and the reading and writing remain separated for me, although it is something I am working on as a pursue my phd.
I am looking for ways that computational design can reveal a critical reading of code syntax, or, how could we bring design and visualization methods to critical code studies?
I would love to know what people think of the work of Bret Victor, who works in HCI and code pedagogy, and has presented ideas on how we can connect syntax to a form of immediate visual feedback. His work is not done in the tradition of hermanuetics, but I wonder if it could be used as a method to connect both writing and reading code critically. http://worrydream.com/#!/InventingOnPrinciple Likewise, the D3.js developer Mike Bostock, created a study in visualizing algorithms, and I wonder if people think this method might also support an interconnection between syntax and interpretation. https://bost.ocks.org/mike/algorithms/
One of the things I find interesting here about the reading/writing question is the intersection with (maybe neoliberal, to raise the specter) devaluation of the humanities--the idea that interpretive and critical practice in itself is not valuable work, but that people must make things (STEM things) to count. So then writing code that is poetic is resistance to that, but so is staking out an argument for the value of critical interpretation.
@melstanfill -- I like this framing of "writing code as poetic." I wonder this might connect back to "writing criticism as poetic" or "life-writing that is poetic" -- as in the traditions such as fictocriticism and écriture féminine. I also wonder if "code as poetic" connects forward to the "from STEM to STEAM" movement, which insists on including a broad conception of the Arts as central to valuing the humanistic and artistic traditions of people who "make things."
@jeremydouglass @melstanfill A tradition I'd add to the two that Jeremy has laid out would be the tradition of indeterminacy and chance operations in avant-garde art/performance and aleatoric music. This actually leads in the opposite direction from what Jeremy has laid out: rather than "poetic criticism" or "life-writing that is poetic," thinking of the code poetry/poetic code problematic from this lands one in the arena of "programmatic writing/performance" (an example here would be something like Jackson Mac Low's Port-au-Prince or Earle Brown's 25 Pages). I don't think it's a mistake at all that there's quite a bit of overlap between the study of avant-garde/conceptual poetics and electronic literature (or digital art writ large), as they could both be described in some sense, as "programmatic writing/performance" which attempts to think of code in a manner that moves toward critical interpretation/reflection.
More specifically, I would say that the links that can be made between avant-garde chance operations and digital poetics emphasizes how the act of coding is always already a poetic act. One could point not only to the chance operations outlined above, an e-lit genre such as codework, or esolang practices, but also to the act of designing a programming language and writing code in said language itself (questions of paradigm, syntax, elegance, etc.). Laying out the links in this manner leads me to more general points regarding how humanistic and interpretive work is always bound up in the act, but gets masked for any number of reasons relating to field, culture, discourse, etc (the neoliberal devaluation of the humanities being a huge one).
So if the CCS approach both wants to foster a relationship between writing code and reading code, and stake out a value for critical interpretation, then the approach is actually doing something quite typically Marxist: marshaling practice and critique (sometimes in concert) to articulate how the masking described above is either maintained or stripped away through coding practices and discourses around such practices, a goal which art practice and critique has attempted to fulfill in other contexts for decades.
I am now getting more interested in this CCS. I actually studied Java many years ago but now I couldn't remember coding in java again. Coding is like a drug and very seductive. I have dropped an unfinished Bible App which I so much like to develop because bufferReader refused to read my codes. I complained to my teacher but he couldn't help me since 2014 I didn't code again even one day only when I coded my website using HTML and CSS. I am happy that @Markmarono,@jeremydouglass and the rest of you who looked into my plight and give me good hope to love the CCS the more. Actually that's why I'm here.
I remember someone, I think Glazier, arguing that code is always already poetry for its indeterminate state--that is, code itself is suspended in a non-space where all its meaning is potential and not definite, because it is dependent on a second layer of representation (execution). Galloway has written that code by its nature (and a crucial part of it being code, is that it) is never read directly, but only indirectly (represented, performed, etc.). CCS probably rejects the totality of these claims, but what I find most fascinating about code is that contradiction of being both protocol-obsessed and infinitely variable (like the rigidness of 6 options paired with the unknown result of throwing a 6-sided die). Like Richard III in a 16th-century Shakespeare play saying "I am determined to play the villain" including the possibility (then!) that four centuries later, Ian McKellen dressed in 1930s fascist attire would say the same thing in a 1990s film. For me, what energizes _reading _code critically is all that not knowing before punching the "execute" button.
So when I think about critical code writing, I wonder, does that still require the same sequences of interpretation and adaptation, human and nonhuman, required to decide surface meanings for creative code writing? Is it creative code writing with a different subtitle, for which it is precisely the stages of variable meaning, the expanses of suspended possibility, that energizes its message? Or is critical code writing the act of intervention into creative code writing, such that the field of possible representations becomes altered and shaped: critical annotations inserted directly into the code that participate passively or actively?
I should mention that this is the first time I've ever seen the phrase "critical code writing."
Zach
Mark, several other people wrote code as part of their critical inquiry in writing 10 PRINT. I wrote an Apple II port, Mark Sample wrote a TRS-80 Color Computer port, and Ian Bogost wrote the most difficult of the ports, to Atari VCS 6502 assembly. And I'm not claiming that is the entire list ... I just wanted to mention this since no one is credited with writing individual parts of the book.
Trying to port, modify, play with, compromise, and otherwise engage with code as a programmer is a great way to be a critic of it.
Thanks @nickm, I was mentioning @belljo cuz he's here, and for some reason Michael Mateas' Maze Walker always stays with me. Glad to have the shoutout to our comrades of 10.
I think it would be worthwhile to delineate what "critical" might mean. It's used far too often, IMHO, without being specific - and mostly in a defensive posture against people who say that DH isn't critical. And apologies for writing out some basic information. I'm doing this just to be explicit.
There's the Kantian notion, in which one delineates the possibilities of some form of discourse. So, the CRITIQUE OF PURE REASON was a systematic exploration of epistemology and the limits of knowledge.
There's a Marxist notion, where critique takes the form of dialectical materialism - specifically that class warfare between the bourgeoisie and the proletariat create specific ideologies that shape experience. But there's also a sense here that untangling these forms
"Critical Making" was explicitly used by Matt Ratto to suggest that understanding these possibilities entails actually making things. We don't reflect purely cognitively, but we do so in groups and when using technology.
Another way to think about this, too, is through the "Making" work of Tim Ingolt, in which humans and non-humans continually make up their ecological materiality - and that acts of making enable us to participate in this process. See also his great article "Materials Against Materiality."
It might also be worthwhile to mention Eve Sedgewick's critique of "paranoid reading," in which every critique is based fundamentally upon suspicion - and Sharon Marcus's "surface reading," where nothing is hidden, and the intervention isn't about uncovering something underneath.
These are only a few (of many, many, many) that we could articulate. Maybe it would be interesting to put together something that shows how different projects in "critical making" respond to one or another version of "critique."
My sense is that creativity can and should be a form of critique, but that those two terms aren't necessarily synonymous. Likewise, I get a little grumpy when people say that "critical code studies" is reading code like poetry. Certainly there are ways to read poetry "critically" in terms of a specific ideological or cognitive mode. But I don't think every reading of poetry is "critical," simply because it is about interpretation.
I'd like to link back to one thread of the conversation from week 1:
@JacqueWernimont said: "Credit. Credit is interesting, but for me it's not the most interesting part of the story. I'm particularly interested in the error introduced by Lauren and others' reactions to it. Presumably part of the logic that went into dismissing the error and Hamilton's insistence that it be built into the training/code is that it was a child's mistake. Something so silly that no professional (adult, white, male) astronaut would make. The history obviously played out very differently than what those higher up the command chain presumed.
So for me, this story is about control rather than credit or contribution. The things we can learn when control is ceded."
Control seems to be a crucial part of coding both in terms of design and infrastructure. I'm reminded of Virginia Eubanks' Digital Dead End, which highlights the ways in which women of color who work in the tech industry have little control over their own data. They often are relegated to contract labor and therefore have little control over their work schedules, opportunities for advancement, and/or professional development.
Many of the suggestions we've offered suggest that experimentation, whether through critical making (I love Kim Knight's Fashioning Circuits project) or infrastructural changes, suggest that creativity and experimentation are strategies for promoting change, transforming tech environments, and discovering new possibilities (or finding errors in our design, as Lauren did).
So, how can we harness the creative opportunities that coding offers to promote such change?
Though the other 10 PRINT authors are already aware of it, I'll also mention that a lot of the response we got was just people translating 10 PRINT into other languages. My favorite is the Enterprise Java version.
I try to stay away from definitions of criticality in DH; it reminds me too much of art vs. craft arguments from my MFA days. However, that comparison does lead back to the discussion of what "counts as work" in academia. There's a legacy of textual culture that DH is having a lot of trouble getting past, and–though less so than many areas–to some extent I think CCS falls into that pattern. My hope and belief, though, is that focus is more about pragmatic internalization of academic reward systems than the intellectual curiosity of those who are engaging in CCS.
For instance, I think the Enterprise Java port above is a wonderful critical interpretation of the culture surrounding a programming community and is a self-contained (if sarcastic) argument in its own right. But, to get back to another part of the discussion, I'd also say there are three audiences that will interpret it differently: people who don't know Java, people who are familiar with Java as a language, and people who have spent a lot of time working with Java and Java programmers. If that port were made in an academic CCS context then the third audience might consider it a critical interpretation while the first doesn't. Writing about the port–impressing textual culture on code–is supposed to be how academics get around that problem, but I have serious doubts about how well the message translates. I agree that critical and creative are two different things, but critical insight occupies that same space between familiar and alien that I talked about creativity living in earlier.
I agree with the notion that reading code like reading poetry is a bit off the mark, but mostly because–even knowing the arguments–I wonder why we default to treating code as poetry. Some code certainly fits that model, but I'd say it's most often code written with human readers in mind and some idea on the part of the programmer that they're attempting something different than everyday, making-things-go coding. If anything, I think we're more like film scholars who are studying scripts: aware of the fact that most of what we see is an intermediary logistical step but mining it for insight anyway.
This is one of the points we raised in a course I recently taught called "Programming and Poetry," which included readings from @mrheeloy's robot love poems and Neil Aitkin's poems about code-as-practice (especially "Compile" and "Object"). One of the early things we also read was a post on Medium, "Programming is Poetry".
That said, while coding is certainly a creative, sometimes poetic act, I don't think it's poetry per se, unless we significantly expand the concept of poetry. Part of the issue is that, unlike poetry, code has two distinct audiences with very different requirements. Certainly, code is written for other coders to maintain, modify, and extend (else why not write all code in binary?) and in languages that make it possible for humans to understand more easily how to convert functional requirements into executable instructions (thankfully we don't have to write in binary or assembly these days). But, as is obvious, code is also written to do things, to instruct the computer on how to arrange its bits in ways that are meaningful / useful for other humans: the users. The more human aspect of coding, the humor and allusions, tend to appear—as we've seen in the reading of comments in the Apollo Guidance Computer code—in the margins, in the non-executable parts that a compiler / parser strips out and ignores.
Great: all this is ground @markcmarino and others have already covered. What interested me in my course was to take the metaphor for code-as-poetry and to reverse figure and ground, a move common to poetry. What happens when we read poetry as code and assume that the mind of the reader is the "computer" processing the fuzzy linguistic instructions of a poem? Here, Peter Stockwell's and Reuven Tsur's work on cognitive poetics and George Lakoff and Mark Johnson's Metaphors We Live By became useful in interesting ways. Suddenly, for example, we have a metaphor for understanding poetic conventions like enjambment as activating our internal Markov chains predicting what comes next, then subverting our predictions while preserving the aura of the prediction in our "cache" (reminds me a bit of the information leak problems exposed recently by the Spectre / Meltdown bugs). In fact, by positing poetry as code, we gain a perspective on the mechanics of poetry and how it / we as readers create meaning: it occurs largely through the activation of existing cognitive schemata, then through subverting or deranging those expectations. A poem that does not surprise our circuits is flat, dull.
Cognitive poetics also leads us to think about the hardware of cognition or "embodied cognition" as Lakoff, Johnson, and numerous others have called it. Most computer code runs equally well on any platform, until you get into the lower levels of coding, and poetry is the same, provided the reader-computer knows the language. This is the key insight in Metaphors We Live By: that nearly every thought we have is in terms of embodied metaphors and that these are encoded in systematic ways. Time is a path we walk along; argument is war; ideas are objects that can be exchanged; and so forth. There's a great deal of parsing, processing, and context in every linguistic utterance that we must decode and translate into internal structures of thought before we can understand anything. But the meaning, feelings, memories, and beauty each reader finds in a poem depends so much on context: where is it being read, what age is the reader, what memories and other poems does the reader bring to bear, what type of body does the reader have, etc.? Even though we may, like Adrienne Rich, "dream of a common language" and, in literature, partially achieve it, the poem is different every time it is read because the system (i.e., the reader) processing it is unique and different every time. Imagine is computers changed as radically every time they ran a piece of code! Poetry, then, becomes a way to play against / with these common patterns of linguistic processing.
So, to come back to code as poetry, perhaps truly poetic code might be code that uses the compiler / parser in novel, unexpected ways or that exposes how each computer is, in its own way, unique. This is the realm where particularly elegant, overly clever, or purposefully obfuscated code seems to reside. It's stunning (or infuriating) precisely because it's no longer code-as-craft, but code as personal expression, subverting common procedures, taking advantage of the deeper structures of the language and computing environment, to leave the particular coder's mark. Yes, writing code is a creative act, but no, it's not all poetry.
I am very grateful for the link you sent me. Thanks once againsir @belljo
Our comments over on @gtorre's "AI Prison" thread have me wondering to myself about some of those 10 PRINT ports, continuing @erwig's difference between sense and reference (from Frege). I know people have come up with ways to replicate what 10 PRINT does on various platforms, but that all depends on what we think 10 PRINT does: what is the essence of 10 PRINT?
Does it (pseudo)randomly select from two diagonal characters printing something that looks like a maze on the screen in an never-ending scroll?
Or does it create an (Somewhat) unexpected pattern out of two platform-specific characters in a loop that takes advantage of particular (and basically unique) platform constraints in a one-line program? If that latter case, a 10 PRINT port could look quite different from 10 PRINT and still be a port of the essence of the program....
I'd also add a definition that has a prehistory in Marx but has morphed substantially--"critical" as paying attention to power. So what does Critical Code Studies or Critical Making or Digital Humanities as a critical project do if that's what "critical" means?
Bear with me if this is left field, but this reminds me of @ebuswell's conversation in the other thread about code vs. state, and the ways that they're "properly" supposed to be separate, and the code is not supposed to change as it is run, but what if it does?
I am going to cite a few block quotes from a sub-conversation happening in this thread, which is more or less asking the question: "what does the 'critical' signify in Critical Code Studies?" This conversation is explored in @ebuswell 's excellent code critique, but seems to figure more in this thread than the other.
I am also interested in looking into Ulmer's work. I am somewhat skeptical of any claim that critique or critical theory is a method of hermeneutics, to the extent that hermeneutics is understood as a static interpretation that is representationalist in nature, that is, a process wherein "subject" and "object" are posited as discrete and knowable identities that can act or be acted upon. I would characterize interpretation instead as a co-constituted (or intra-active, if we're looking to Barad) creation of meaning. I hinted at this in the code as poetry thread--meaning is not a stable quantity that can be isolated at either the subject or object level, but is instead a dynamic matrix.
Critique, then, would be a sub-genre of interpretation. It is inherently creative. It should not be thought of as a parasitic process, but a symbiotic one. Borrowing from the line of thinking from Kant to Foucault ("What is Enlightenment?" and "What is Critique?") and Derrida ("Eyes of the University") and finally to Butler ("Critique, Dissent, Disciplinarity"), critique is interpretation that cuts against the grain; an affirmative fabulation that responds directly to power structures and systems of control. As Butler ends her essay, "Critique, Dissent, Disciplinarity," “Could it not be that critique is that revolution at the level of procedure without which we cannot secure rights of dissent and processes of legitimation?” (795, emphasis mine). This "level of procedure" she speaks of reminds me, of course, of Ian Bogost's "procedural rhetoric," and other interventions germane to the present one. But the takeaway is that interpretation and critique are things we do, and this "reading" versus "writing" of code is really a delineation of (as was mentioned in the code as method thread) "writing prose" versus "writing code;" two productive activities.
Do any of these theoretical caveats have a purpose? I think they strike to the heart of @ebuswell 's discussion of politics, and to broader questions of the value of digital humanities work. The value of CCS and digital humanities "labs" is called into question perhaps because of this fundamental misunderstanding of the activity of thought, whether that thought is computational and iterative, or bio-textual and repetitive. I just find it dangerous to participate in this fiction that critique is somehow distinct from production.
hmmm...maybe this separation of critique and production is just a bit judgmental?
I agree that critique is not distinct from production but, as counter example, should we argue that anyone not able to paint should not critique paintings?
I do not think that would be correct. Many philosophers, writers etc. (including academics) wrote interesting things about art without being themselves practitioners. I could push the argument further by asking: should we not consider any opinion (critique) coming from a non-practicing audience? Avangarde music did not go much long with that approach. In spite of a century of experimentation it still remains a marginally known (or appreciated) niche.
I would be in favor of having anyone “yacking and/or hacking” in whichever measure they feel comfortable with.
From a personal perspective, being both an academic and a practitioner involved in the field of digital/media art, I tend to use practice-based methodologies in my research/practice. I came to know about CSS through a need to (re)connect with humanities while distancing myself from technology driven approaches and paradigms of enquiry which I feel dominates in my area.
It is probably for this reason that, to me, the question:
reminds me too much of that kind of utilitarianism informing scientific research and associated funding schemes.
To address one of initial questions/provocations of this thread I would argue that to increase or to decrease a “doing” culture don’t matter. I would be more concerned about scientific methodologies/paradigms informing too much the speculative/dialogical nature of art, humanities and philosophical studies/practices.
Not beacause of hate for science, logical positivism or utilitarianism but because of an appreciation for diversity.
This is such a rich thread. A smattering of thoughts:
Yeah, this is definitely something I had in mind when crafting that question. I did my M.A. at PSU (Portland, not Penn), which has a very active creative writing program, at the same time as one of my best friends was finishing up her undergraduate at PNCA. Not having direct experience in either, I may be wrong, but my impressions were that the way that an art education relates to the history and theory of art is radically different from the way a creative writing education relates to the history and theory of literature. While art and its theory and history all went into, as @malazj said, a "mutually constitutive creative apparatus."
Now, I suppose for code we can add in a third term there, for history and theory of code vs. coding, but actually the institutional apparatus lines up pretty differently. Computer science departments tend, actually, after some very basic coding literacy classes, to teach about the abstract analysis of algorithms, data structures, databases, operating systems, etc. The students that graduate from these programs, even at the MA level (and I hired and trained a few of them at a company I worked for) rarely learn to either read or write real world code. What they do learn on average better than the autodidact is things like big O notation, how to write sort algorithms from scratch (hint: don't do it), etc. So in some ways CCS is actually closer to computer science than either is to industry computing. And CCS might actually teach you more about industry computing than CS.
At any rate, I like the mutually constitutive creative apparatus, and I'd like to see more of it.
Yeah, I think this is the flip side of my situation. That is, the same situation from a different perspective. For whatever reason, I found myself writing code. Somehow I perceived it as important. Now, after the fact, I'm asking what it all meant. It seems like you're exactly in the position I was before, gravitating towards writing code, not sure why, not sure the relationship. I won't assume about your particular situation, but in general, this flow towards the actual writing of code is going to involve not only people who have written it, but those who haven't. And problematically, maybe also those who don't know how to code. Practically, I'd like to say: let your code come naturally if it does and if it doesn't don't worry about it. On a certain level, my experience was of something appearing as suddenly obvious once I'd stumbled my way 99% of the way towards it. The exigencies of every project are different and it's not clear prima facie that they should or could all include some code component, even if we limit the question to projects about code. But that being said, there's also that mysterious (/funding-based, maybe) push towards coding about it, whatever it is.
This is an excellent point: in either case, we are producing writing, which always suffers interpretation. Let us not forget that, and imagine that we are somehow producing unmediated knowledge.
However, we would do well to look at the opening of Adorno's Negative Dialectics:
The same that is true of concepts is even more true of writing. By necessity, we write, but are we then somehow not producing concepts? And do those concepts not have as their content a truth claim on the world? Is the writing somehow more real because it is made of material substance, rather than ideal substance? Rheinberger's An Epistemology of the Trace comes to mind as a counterexample. Rheinberger analyzes scientific organization and output as inscription systems and inscriptions. But this results merely in skepticism about the nonmaterial signified—signifiers point to signifiers ad infinitum. Thus, the rejection of hermeneutics or mediation as such.
We might note, however, that there is something about the execution or compilation of code which really does translate signifiers to signifiers. But of course CCS very explicitly rejects placing this process of translation as the sole arbiter of the meaning of code.
Anyway, yes to accounts of writing as production, as long as this reminds us to pay attention to mediation, rather than simply erase what is being mediated.
This week has me thinking a lot about "meaning" and "interpretation".
At Todd Millstein's behest, I've been reading Godel, Escher, Bach, an Eternal Golden Braid by Douglas Hofstadter, and one passage from that book seems particularly relevant to what we are doing here in the Working Group. In the second chapter, Hofstadter talks about formal systems of representation and includes somewhat simple systems (represented by a ASCII characters: MUI, p, q, -) which can be built into more complex statements (or theorems) by following a series of rules (like a programming language). Anyway, without summarizing the entire book's argument here, let me see if I can articulate one distinction.
Hofstadter offers two concepts: "meaning" and "interpretation." Interpretation comes from taking one formal system and relating it to something else at random. The one system then comes to stand in for the other, but the relationship is what I'll call arbitrary and incomplete.
On the other hand, one might find a relation (or, in his terms, an isomorphism) between two systems that maps more closely. In this case, a correspondence exists between "theorems" (or allowable statements in one system) and some portion of reality. One of his systems -- p --- q ----- turns out (spoiler alert) to map onto addition: 2 plus 3 equals five. Again, he calls this isomorphism "meaningful" because the theorems and "truths" correspond. In other words, the statement in one representational system and the statement in the other are both true in their respective systems.
It strikes me that in many of the threads this week we are seeing a braid of these concepts of interpretation and meaning, one that often gets us into a warp and wave but at times leaves us tangled in knots.
Margaret's ( @mrhee ) thread in which she challenges us to translate poems into code asks us to treat an act of interpretation as an isomorphism, a creative act of seeing and yet producing a relationship as though it were an act of porting from one programming language to another. (I'm trying hard to avoid "translating" since we know translation is not a transparent process.) And yet, no surprise among humanists and artists, in another discussion thread, we are finding so much room for interpretation even in a more formal porting from one formal system (programming language) to another (see the thread about porting @gtorre's program poem and @erwig's gesture toward Frege).
Evan ( @ebuswell ) has offered his conditionless language as noneleatic. Again, a critical act that appears to involve meaningful isomorphism in Hofstadter's terms but obviously involves so much creative interpretation (in my eyes) for it to allow him to discover and articulate points about symbolic representation in a completely other realm economics. (Such fascinating lateral thinking here). At the same time, his claims can prove a stumbling block to those looking for these systematic correspondences, Hofstadter's meaningful isomorphisms. We take issue, and perhaps rightly so, with aspects of the correspondence.
John Bell ( @belljo ) has had the most fun, in my eyes, mapping an act of re-use as an act of creativity, an isomorphism so paradoxical that it requires the anarchic Calvin and Hobbes for its spirit animals. And yet, I am compelled by this interpretation.
Look in the code critique threads, too. Gregory Bringman ( @gregorybringman ) is pressing on the isomorphism between the Turing Machine and Maxwell's Demon. At the heart of his thread, I see the question -- is this a meaningful isomorphism or a loose interpretation disguised as a close correspondence? And then: What other meaningful correspondences might we find?
And I have had my own mind blown by what I can now see as a meaningful isomorphism between an Excel spreadsheet and a text-based coding environment, in which correspondence one is merely (although we know this word is a troublemaker) a representation of the other as (on some level) all software GUIs are. But here is a software GUI that is a programming environment disguised as book-keeping, which is, perhaps, also coding.... which has implication for (going back to Week 1) who gets counted as programmers.
So this brings me to a point of contention that we have had before in Critical Code Studies between those who see their work primarily in the realm of formal systems (programming languages) where there are tighter correspondences between formal symbolic representations in one and another -- where someone must watch out for statements that are not, in Hofstadter's formulation, theorems -- i.e., statements that don't compile. And those of us in the language and visual arts -- where we can make partial correspondences not only meaningful (in a broader sense) but also productive, uninhibited by the need for our works (essays, poems) to compile, getting to use words "with all the usual vagueness of of words" as Hofstadter puts it (50). (And of course, the code artist walks the tightrope between (escapes the straightjacket of) both worlds of meaning.
And it is partially the work, of some of we gathered imps, following Derrida but also Cixous and Haraway and Gates (Henry Louis, not Bill) and Halberstam and Deleuze and Guattari, to identify the places where even the most close-knit correspondence has something extra that adds a bit of significance (just to add a third term here) and we have programming poets who can show how the correspondence can be used systematically to produce surplus significance.
So, the next time we find ourselves banging our heads about whether such claims in code, such leaps of correspondence, are appropriate -- perhaps it would help to note that we may be wrestling between views of meaning and interpretation.
Hi all, apologies for being late joining the conversation but I have been rather ill with flu.
I just wanted to make a connection (both methodologically but also theoretically) with the work of Bernard Stiegler, particularly his notion of "digital studies" which has a lot of crossover with the work of CCS. Here is some of their work and discussions
One of the most interesting ideas they have been working on is the notion of a contributory economy, particularly in terms of social annotations. The idea is to allow a community of annotators around a digital artefact, whether code, video, text, etc. and thereby create the conditions for critical means of thinking about and understanding digital technologies. You can see an example of the technology they have been coding themselves here: http://polemictweet.com/enmi13/session-1/polemicaltimeline.php
This notion of a collective sense of annotation as a means of reading complex objects I find very suggestive, and something that has been worked on in the CCS groups. I also briefly note a renewed focus on web annotation by the W3C. Could this be something that CCS could concretely connect and contribute to?
Best
David
Absolutely. This is a top priority for collective work. We're having good luck with our work format-based work on Apollo 11, but annotation puts us in the talmudic space of the margins that is so productive. You can recall our attempts to annotate code through Google Docs back in CCSWG and in Scalar/ACLS Workbench in CCSWG14 and 16. @craigdietrich and Erik Loyer had added features to annotate code with multimedia elements, pursuing Craig's dream of "Magic." I had tried some experiments in Border Codes. I think we had even talked about using a versioning repository or Git for the site for our commentaires.
Are there ways you imagine us contributing more than just as end users?
I think that most of these tools have fallen a lot short of the kind of web annotation that the digital studies network has been theorising. For a start there is the question of temporality and how annotating over time is incorporated -- interesting to note that the digital studies network has been trying to produce an annotation system for time-based media -- but also how intersubjective communication in annotations should work. And this is really only trying to think of text (you rightly link to multi-modal forms too). It seems to me that the dimensionality of digital media is bizarrely 2D, we haven't really thought about how social annotation could be an extra dimension(s) around a digital artifact.
Rereading and found this to be such a vital intervention from @malazj
Specifically as someone who often looks as tech and is trying to push code studies and digital studies to engage performance much more deeply. How a performer trains and how performance historian/dramaturg/ literature professor et al approach a play are varied . And too often in code and tech the multiple layers and dynamism with in that are not expressed .
So algorithms are discussed in bias non bias not what are the multiple pathways this object can be engaged and how do those lenses of engagement influence each other
Yes! Can I get you to elaborate a bit on this point?
@markmarino, please elaborate more not a bit only.
FYI, this just came out, so clearly our discussion is au courant
:
https://www.routledge.com/Applied-Media-Studies/Ostherr/p/book/9781138578265