In late 2020, Winnie Soon and Geoff Cox published the open access book “Aesthetic Programming: A Handbook of Software Studies”. Together with a Taiwanese working group, we are also involving the local community to translate it into Traditional Chinese language (see here for the discussion thread on the politics of translation as part of CCSWG22).

In summary, the book addresses the cultural and aesthetic dimensions of programming from its insides, as a means to think and act critically, offering an applied and overtly practice-based approach to understanding the importance of programming. Our intention is for readers to also become writers in the sense that they acquire key programming skills in order to read, write and think with, and through, code. We feel that it is important to further explore the intersections of technical and conceptual aspects of code in order to reflect deeply on the pervasiveness of computational culture and its social and political effects — from the language of human-machine languages to abstraction of objects, datafication and recent developments in automated machine intelligence, for example. Moving beyond a STEM focus, the book develops discussion of power relations that are still relatively under-acknowledged in technical subjects, concerning class and capitalism, gender and sexuality, as well as race and the legacies of colonialism - issues that are already familiar to the critical code studies community of course. This not only relates to the politics of representation but also nonrepresentation: how power differentials are implicit in code in terms of binary logic, hierarchies, naming of the attributes, and how particular worldviews are reinforced and perpetuated through computation.

Details of the book

The book contains 10 chapters + 1 bonus machine generated chapter, containing both the technical and basic principles of learning to program with sample code explanation, as well as wider political, cultural and social issues (also see : http://aesthetic-programming.net/). Each chapter starts with a flowchart that serves as the starting point to exemplify our approach of turning concepts “inside out” and the need to understand computational and programmable objects, relations, and processes in both logical and discursive forms. The current topics of the 10 chapters are: Getting started, Variable Geometry, Infinite Loops, Data Capture, Auto-generator, Object Abstraction, Vocable Code, Que(e)ry Data, Algorithmic Procedures, Machine Unlearning. They are the topics that are currently used in the delivery of the BA course/module “Aesthetic Programming” at Aarhus University, in Denmark.

Forking: An Open Invitation

Importantly, we do not see this book as a fixed and universal teaching resource, but rather a situated curriculum with the potential for extension and customization with other arts and coding communities. Following the free and open source ethos, we want to open up different possibilities for making “cuts” across the various materials and ideas, and encourage readers to fork a copy and produce their own versions; with different references, examples, reflections and new chapters for example, for further modification and re-use (see the respository: https://gitlab.com/aesthetic-programming/book). Responding to the invitation, in 2021, @SarahCiston and @markcmarino forked the book and created the chapter 8.5 entitled “Talking Back,” which sits between Chapter 8 (Que(e)ry Data) and Chapter 9 (Algorithmic Procedures), extending our discussion of APIs and conversational agents. They have also added two new perspectives and structural changes: Code Confession and Code Commentaries, considering the affective relationship and further insights regarding coding. With this open invitation, we want to stress that Aesthetic Programming is not only a book, but it is also a computational networked object, distributed across other spaces and temporalities, made available to both readers and writers alike.

To begin the thread, we invite you to join us to explore the following questions:

1. What pedagogical approaches are useful to teach/learn how-to-code, but also to work with (read and write) code through critical and creative action? What are the challenges in practice (“the real-life cases”) of working across engineering and culturalist traditions? And how to cultivate “problem-posing” rather than “problem-solving” through learning to program?

2. Beyond the solutionist approach of emphasising state-of-the-art technology, big tech normalisation, as well as the ideology of standardisation, efficiency and optimisation that fit into capitalist economy, how might combinations of free and open source ethics, and intersectional feminist/queer politics open up ways of learning to code otherwise?

3. What other themes and topics are useful to explore in Aesthetic Programming? And what are the implications of forking a book like forking software? How to involve and include local contributors and situated real life cases?

Here is more a continuation of the discussion starter, but with a focus on translating Aesthetic Programming and the related issues to open up the politics of versioning, forking and translation. We also see this thread would also work along the line of Decolonizing Code in week 1, posted by @xinxin and @fabiolahanna.

After the launch of the Aesthetic Programming book, we have recently formed a small working group to translate it into Traditional Chinese language, working closely with Taiwanese art and coding communities. The politics of translation has been well-established in general, but what of the specifics of translating a book such as this?

Translation is necessary but impossible. So says Gayatri Chakravorty Spivak, acknowledging not only the inherent difficulty of translating any text into another language whilst retaining its meaning, but also across cultures and logics. It’s easy to see this with English language that has been challenged by postcolonial and feminist scholars for the way it imposes itself as the predominant man-made language of globalisation. But this is no less the case with programming languages that reinforce the hegemony of English as the lingua franca of communication between peoples and technical systems. In the forking of Aesthetic Programming, we are curious to consider translation at the various levels of socio-technical operation - recognising the many layers of translation at work when machines interpret instructions in their own terms. But how do problems of translation resonate more broadly when translating a book about programming that requires precision of language that is both descriptive and active/executable?

Chinese/Machine translation

Translating into Chinese makes a useful case study in this respect, in all its rich variations across history and geopolitical context. Indeed the complexity of Chinese language has taken on a metaphoric role in technological discourse, such as in Searle's 'The Chinese Room' experiment where it stands for the inability of humans and machines to 'think' when using a language that one doesn't understand (thus setting out limits for AI but also implying occidental fantasies and prejudices). More pragmatically, in Google AI language translation, we found that many of the translated Chinese words, and technical terms, follow the style of Mainland China even though the words are selected in Traditional Chinese characters (mostly used in Hong Kong and Taiwan). This is also confirmed by Google, in which the same training dataset is used for both Traditional and Simplified Chinese translation given the many similarities between them (Cattiau, cited in Chris 2017). However, many terms, in practice, are used differently between Hong Kong, Mainland China and Taiwan, prompting reflection on the implications. For example, the title of Chapter 3 - "Infinite Loop" as 無限循環 or 無窮迴圈. Aside from the technical and aesthetic challenges and implications, this raises the question of how the Chinese language model enforces particular hegemonic worldviews that occlude differences. With all the variants of Chinese language, how is this tied to expressions of colonial power that resonates with our use of English? Given the rich variations of Chinese and indigenous languages (such as Amis, Atayal, Truku, Pinuyumayan, in a Taiwanese context), we are curious how we might be sensitive to language diversity that challenges the Western-centrism of programming in English (and inherent nationalisms). We are also mindful of the way that "queer" politics has informed the way that terms can be appropriated/expropriated, as a means to "talk back" (hooks 1989) to the source codes of oppression.

Forking translation

Translation is evidently more than textual dimension as it needs to consider cultural, political and historical contexts, it has always been a forking of sorts. It is a form of cultural reproduction and creation with new forms of interpretation and articulation, a new version attentive to its source. Suffice to say, we are influenced by texts such as Benjamin's The Task of the Translator (1922) in thinking about originality, and the "afterlife" of the translation processes, opening up new modes of thinking and expression. Our examples include how to use languages in ways that fearlessly encourage questioning, measuring, sensing and experimenting within ourselves and the environment in yet unknowable and scientific ways. We add Alexis Pauline Gumbs' poem in the annotation alongside Femke Snelting's definition of a circle while translating Chapter 2 entitled "Variable Geometry". Since the conventional Chinese translation of Euclid's geometry elements (幾何原本) is something seemingly authoritative and undoubtable (see the earlier Chinese translation in 1600 AD by Jesuit missionary Matteo Ricci (利瑪竇), Ming dynasty agronomist, astronomer, mathematician and bureaucrat Xu Guangqi（徐光啓)). That only mirrors the phallogocentric genealogy of Chinese translation in the mathematical and scientific field. We are seeking alternatives that shed new light on the expression of geometry and other key terms, and the naming of attributes and functions.

To continue the discussion threads about forking and translating Aesthetic Programming, we would like to explore the following further questions:

1. Can we think of forking as a kind of translation, and cultural translation in particular? What are the implications of drawing forking and translating together?

2. What other platforms might faciltiate further distributed forking and cultural translation such as DokuWiki, MediaWiki, PmWiki, WikkaWiki, HackMD, Git, etc? How to fork the politics of translation in ways that are sensitive to the cultural situatedness of tools, their descriptions and operations?

3. Is programming necessarily Western-centric? How to resist colonial and profit-driven exploitation of the earth, people, other beings and to reveal the scale of atrocity and neglected narratives? If non-Western, what new lines of oppression are apparent (e.g. the link of language to Chinese nationalism)? How is power encoded in human and machine language? How does local specificity lend additional layers of meaning to an understanding of how words perform or resist symbolic violence? How to pay attention to the procedures that slowly kill languages and restrict diversity, and how to reverse these tendencies? Can programming be sensitive to this or does it necessarily perpetuate dominant modes of address and colonial logics? How to talk back to dominant source codes of human-machine oppression/expression?

References
- Walter Benjamin, The Task of The Translator (1922)
- Audre Lorde - a paper delivered at the Fourth Berkshire Conference on the History of Women, Mount Holyoke College, August 25, 1978
- Alexis Pauline Gumbs (2020). In Case You Wanted to Save the Planet. Transition, 129(1), 46–54.
- Chris (2017). "神奇的 Google Translate，背後到底蘊藏哪些機器學習科技？" TNL Media Group. < https://www.inside.com.tw/article/9231-google-translate-machine-learning-taiwan&gt;
- Ricci Mattew (利瑪竇), et al (1600 AD). "Euclides 歐幾里得, Ji he yuan ben 幾何原本," Library: Max Planck Institute for the History of Science. https://libcoll.mpiwg-berlin.mpg.de/libview?url=/mpiwg/online/permanent/library/02NT95YF/pageimg&start=21&pn=23&mode=imagepath
- bell hooks (1989). Talking Back: Thinking feminist, Thinking Black. South End Press.

A basic premise of my book Poetic Operations: Trans of Color Art in Digital Media is that scholars, artists and activists studying algorithms need to consider both race and gender in their analyses, and similarly that people studying race and gender need to study algorithms. In the introduction, I propose three methods of algorithmic analysis:

1. Analyzing existing algorithms
2. Writing our own algorithms in functional code, pseudocode or code poetry
3. Analyzing operators

Here is an excerpt from Poetic Operations expanding on this, starting on page 6:

“Algorithms do not require digital technology and were invented far earlier than digital computers. They are similar in form to both recipes and rituals. Algorithms are not new. The word algorithm is a derivation of the name of the scholar Muhammad ibn Musa al-Khwarizmi, who lived from 780 to 850 AD and is credited with inventing algebra in his book Dixit algorismus.20 His name was translated from Al-Khwarizmi in Persian to Algorithmi in Latin, which later became “algorithm” in English.21 He proposed methods, algorithms, for solving calculations with uncertain quantities. By starting with a list of parts and adding a list of operations, instructions for how those parts interact, one can create an algorithm. When I speak of algorithms, I am talking about code. I started writing algorithms in the fourth grade, then later studied computer science for my bachelor’s degree and worked as a software engineer for five years. But to understand algorithms, you do not need to be a programmer. You can also understand an algorithm as a recipe. A recipe has ingredients and steps, just as an algorithm has variables and instructions. Think of the algorithm for cooking chicken: get the chicken, oil, spices, and a pan. Preheat the oven. Oil the pan. Put the chicken in the pan. Spice the chicken. Put the pan in the oven. The ingredients in the recipe correspond to the variables, and the steps correspond to the instructions, lines of code that describe how the variables are related. Throughout this book, I demonstrate three methods of algorithmic analysis: the identification of operations and operators, a method of breaking down a problem into its basic elements and instructions; the analysis of existing algorithms in media and technology, including reverse engineering; and the creation of new algorithms, in functional computer programming languages, pseudocode, or code poetry. I propose that algorithms can be useful for the study of arts and humanities, deepening our ability to theorize social formations, including race and gender. Algorithmic analysis examines algorithms, uses algorithmic methods such as identifying components and actions, and uses algorithms as tools for analysis and creative practice. The goal of algorithmic analysis is not to attempt to describe artworks with totalizing precision, but to see how algorithms can help to better understand art and poetry, as well as the social dynamics embodied in artworks. Adding a consideration of algorithms present in a work does not displace other ways of analyzing that work but adds to the many methods of analysis available to those engaging in critical analysis.”

Let’s look at Yoko Ono’s fluxus poem, which she called an “instruction painting”, as I discuss in Chapter 2 of Poetic Operations, two poems from Fahima Ife and a short poem of mine, and write our own code poems! These can be poems describing movement, poems about code, about our lives or about another literary work, for example, the sky’s the limit!

Voice Piece for Soprano by Yoko Ono

Scream.
1. against the wind
2. against the wall
3. against the sky

Taking inspiration from fahima ife’s book Maroon Choreography, below, how can we bring our own experiences of oppression and embodiment to the studies we are engaged in to question their form? What demands from academia do we bring to critical code studies that shape our assumptions about what it must require?

From Maroon Choreography:

Excerpt from my forthcoming book:

Beloved May
I want you to know
that a Tuesday evening,
holding you in my arms as the light turned to lavender
as the sun was setting
feeding you
waiting for the sun to go down
so you could fall asleep
felt like the best thing that had ever happened
{and the nights when you would wake every hour crying,
Were some of the hardest that had ever happened}
but losing you
was the hardest, most shattering pain I had known.
{I know I haven’t lost you,
you’re just far, across so many dimensions,
and I know you’re happy there
{is there a bracketed timeline,
a reality where we were not separated?}}
I was so lucky to have any given moment with you.
When you couldn’t sleep,
{in the middle of the night again and again}
I held you, rocked you, and sung to you quietly,
trying to keep the light low so as not to wake you more,
being, again with you, in the most beautiful moment I had ever known.

//

I invite you to share a short code poem in response to these poems, or your own analysis of these poems, and/or questions. I invite a discussion of the {} operator in these poems and what possibilities it opens up. I think these poems can be interpreted as code poems, due to the inclusion of algorithmic logic, procedural logic and operators from programming languages, but some would disagree. We can compare these with functional code poems and the Mezangelle poems of Mez Breeze. I look forward to hearing your thoughts!

I then wrote a text called [A][lie][nation], a play on alienation, inspired by Giorgio Agamben to decode this political mess.

There were two works related directly to code and syntax in the expo.
First is a poem, engraved on plexiglass. It was my first attempt to write a poem using only the syntax of the code. Working with code as a language and seeing the esthetics of it and leaving the function. I was trying to create an alternative queer language for speaking with future robots and at the same time readable by anyone even with no coding skills. It is kind of half serious as it is an artwork for a specific context and the game was to deliver a story, not only about the absurdity of the passport and the citizenship but also about colonialism and white supremacy. And how the technology in the west is built on brown bodies like my alienated body.
On the other side of this storytelling, I was having a beautiful time writing and playing with language, and I would love to hear opinions about the process, the work, or the code itself.

The other work was a letter explaining trauma for future robots, it started as a text also with code syntax and then it turned into a binary code, and then into a sound piece, like a coded code that a robot has to listen to and decode and understand. The sound piece is 22 hours long so I can't really share it we can only talk about it in its absence.

this is the first poem:

When annotators mark up a recipe, they often are performing one of two actions--regulation or expression. In cases where an annotator has made structural changes to a recipe--changing ingredients, deleting lines, rearranging elements, etc.--the annotator is regulating what the recipe is or might be. For example, the annotator has marked out certain lines of the recipe for Franklin Cake and replaced some of the measurements with their own adjustments. Rather than existing beside the printed recipe in the margins, the annotations in this case have been mixed with the printed text, made to be inseparable from it. Through these crossed out lines and additions, the annotator is expressing their authority to modify--an authority granted by the genre of the recipe itself, which lends itself to customization and personalization. We might think of this as akin to the way that, for instance, markup doesn’t merely rest on top of text but instead constructs an entirely new object. Or, how comments on code can be just as critical to that code’s legibility as the code itself. In these cases, when a new recipe is produced through annotation, the annotations and the printed recipe work together to improve the overall functionality of the base-recipe.

Alternatively, when annotators aren’t making structural changes to a recipe, they often are offering qualitative or expressive statements. For example the quality of the recipe for Hickory-Nut Cake has been verified by an annotator who has written “Tried-Real good.” When running these “quality checks,” as they might be thought of, annotators often also offer interpretive conditions to their stamp of approval. In this recipe for Sugar Biscuits, an annotator has added “# a very good cake for children” to a recipe for sugar biscuits alongside, ironically, a curly brace. In this instance, the annotator is vouching for the quality of the recipe but also offers conditions under which this recipe might meet the annotator’s expectations--in this case, when the biscuits are being prepared for children. In these cases, the annotator is using the expressive power of annotation in order to ensure that the quality of the recipe can be guaranteed, but particularly under circumstances which the annotator has outlined, according to personal preference and taste.

The tendency for both annotations in recipes and computer code to resist staticity is a key trait they share. In both cases, authority is both flexible and shared amongst authors and readers and modification is not only permissible but standard practice. The procedurality of both genres emphasizes the technical expertise required to modify--and to modify so boldly as to erase or cross out the original text.

In addition to noting their similarities, however, I am also interested in noting how the differences between recipes and code might be useful, as well. For instance, many cookbooks act as almost genealogical records with recipes passing from family member to family member. As some of our discussions from previous weeks have also shown, while code (like recipes) can have a rich sense of community, mutual aid, and in some cases a concept of multiple ownership, overcoming the chauvinism within the programming community can be incredibly difficult for novice programmers.

I wanted to start this thread not only to think about points where recipes and code converge, but also the key places where they diverge. What do recipes and code have to say to each other? What happens when we think of a recipe as code and code as a recipe? Do recipes and code share an aesthetic or aesthetic goals?

We offer the bonus chapter in the book Aesthetic Programming: A Handbook of Software Studies in the form of an “Afterword: Recurrent Imaginaries,” a machine-generated chapter based on the contents of the book, on what has been learnt, and what might be unlearnt. In chapter 10, Machine Unlearning, it contains the sample code that is adapted from ml5.js - CharRNN, ported by Cristóbal Valenzuela with additional contributions from Memo Akten in 2018. Instead of using the pre-trained model provided by ml5.js that was trained using the literary works of Virginia Woolf, we offer another pre-trained model based all the chapters of this book. In this way our example learns from previous chapters and generates a new text based on the generalized style of the others. Of course there is a process of reduction here that exemplifies some of the political issues with regard to knowledge production.

The training process uses a “Recurrent Neural Network” (RNN) and “Long Short Term Memory” (LSTM) that analyze and model sequential data, character by character. Both are useful in terms of character-by-character training because the order, and context of the text are both important to generate sentences that make sense to human readers (this is related to the field of “natural language processing”). This recurrent type of neural network can capture long-term dependencies in a corpus in order to make sense of the text pattern through many iterations of the training process, using markdowns in the form of characters and symbols from each chapter as raw data. What we end up with more or less makes sense, in its processing of text, but also source code, image links, captions, and so on, but most importantly with the machine generated text in the bonus chapter it provides an insight into how a machine learns from our book in contrast to what the readers of the book might have learnt. Here we return to one of the main objectives for the book, i.e. exploring some of the similarities and differences between human, and machine reading and writing: what we refer to as aesthetic programming.

We are interested in how this book might open up recurrent imaginaries for aesthetic programming, in the form of further iterations, and additions to chapters by others. We are inspired by Ursula K. Le Guin and woud like to delve into the imaginaries of reading, writing, coding and thinking: “As you read a book word by word and page by page, you participate in its creation, just as a cellist playing a Bach suite participates, note by note, in the creation, the coming-to-be, the existence, of the music. And, as you read and re-read, the book of course participates in the creation of you, your thoughts and feelings, […] the ongoing work, the present act of creation, is a collaboration by the words that stand on the page and the eyes that read them” (1977-1978).

let charRNN;
let textInput;
let lengthSlider;
let tempSlider;
let button;
let runningInference = false;

function setup() {
  noCanvas();
  // Create the LSTM Generator passing it the model directory
  charRNN = ml5.charRNN('models/AP_book/', modelReady);

  // Grab the DOM elements
  textInput = select('#textInput');
  lengthSlider = select('#lenSlider');
  tempSlider = select('#tempSlider');
  button = select('#generate');

  // DOM element events
  button.mousePressed(generate);
  lengthSlider.input(updateSliders);
  tempSlider.input(updateSliders);
}

// Update the slider values
function updateSliders() {
  select('#length').html(lengthSlider.value());
  select('#temperature').html(tempSlider.value());
}

function modelReady() {
  select('#status').html('Model Loaded');
}

// Generate new text
function generate() {
  // prevent starting inference if we've already started another instance
 if(!runningInference) {
    runningInference = true;

    // Update the status log
    select('#status').html('Generating...');

    // Grab the original text
    let txt = textInput.value();
    // Check if there's something to send
    if (txt.length > 0) {
      // This is what the LSTM generator needs
      // Seed text, temperature, length to outputs
      let data = {
        seed: txt,
        temperature: tempSlider.value(),
        length: lengthSlider.value()
      };

      // Generate text with the charRNN
      charRNN.generate(data, gotData);

      // When it's done
      function gotData(err, result) {
        if (err) {
          console.log("error: " + err);
        }else{
          select('#status').html('Ready!');
          select('#result').html(txt + result.sample);
          runningInference = false;
        }
      }
    }
  }
}

Code:
* run the code: https://aesthetic-programming.gitlab.io/book/p5_SampleCode/ch10_MachineUnlearning/
* source code: https://gitlab.com/aesthetic-programming/book/-/blob/master/public/p5_SampleCode/ch10_MachineUnlearning/
* Afterword: Recurrent imaginaries: https://aesthetic-programming.net/pages/afterword-recurrent-imaginaries.html
* Machine Unlearning: https://aesthetic-programming.net/pages/10-machine-unlearning.html

One of the interesting sections of the generated bonus chapter:

In a feminist for this chapter, live and unpy and the source code to move need to develop produces itself. Chapter 8, “Que(e)ry data,” trans. Face) has a class, a “smart” that is returns a closer loops are developed a modifying code with the code or solve an auga was partly rendering to the technical intelligence as a form of software and new emoji stairs are requires itself — to further identify able to mered model in the dataset by noats in order to train how cultural and powerful writes injustices that look with archificational logics,19 declared the network for political and changing that our deaden, that coding it operative file, you learn to Chinister and syntax continue to show the credentials, and distributed mobil purposes, and are contingencies which properties and behaviors, made server libraries and adding the Universals us too and happens entries that we do not just automaticulas on focusing of this sense of hiding up the present in generator form from software and originally deeply encourage the execution, and commerciculusing of learning to develop because the function draw(), the program and ellipses is a new syntax with other syntaxes from the curated by specifying compring try was the web cam tracker practices and conceptual thinking to use.

Discussion Questions:

1. Can a machine respond convincingly to an input with an output similar to a human — or more precisely — can it mimic rational thinking?
2. How might combinations of free and open source ethics, and intersectional feminist/queer politics open up ways of learning and unlearning?
3. When it comes to the book/source as a whole, which alternative knowledge and aesthetic practices emerge as a consequence?