Would it be useful to compare features? Or compare passages of code that create the same effects? Also, I wonder if we should narrow this thread to the first two, since at least Inform 7 is quite different.

Perhaps we could begin with this question? Which is your favorite language (or favorite aspect of a language) for authoring interactive fiction and why?

The Hitchhiker's Guide to the Galaxy was a text adventure game based on the book/radio/television series that was known in the universe for serving puzzles that made you want to smash your brain with a brick wrapped in a lemon. See this discussion for some common reactions. In this puzzle, and this is a spoiler, you need to have previously removed your common sense so that you can at once have "tea" and "no tea" in your inventory.

I wanted to start a thread to invite you all on a sidequest to explore the code of this game that I encountered at a very formative time of my life. Pretty much influenced everything I do as an e-lit artist. But I do recognize (especially having tried to teach it) that this game goes beyond the usual level of frustration-inducing puzzles that @jeremydouglass has written about. Some argue that the difficulty of the puzzles was tied to a profit motive -- selling more hint books, increasing gameplay time. A later game from Adams, Bureaucracy, would make frustrating puzzles its main theme. I'm not sure this is the best passage to start with, but I'd like to use this to open a code exploration of this game and perhaps also The Restaurant at the End of the Universe code, which I am just learning exists!

<ROUTINE SCREENING-DOOR-F ()
     <COND (<EQUAL? ,SCREENING-DOOR ,WINNER>
        <COND (<AND <VERB? TELL-ABOUT>
                <PRSO? ,ME>>
               <SETG WINNER ,PROTAGONIST>
               <PERFORM ,V?ASK-ABOUT ,SCREENING-DOOR ,PRSI>
               <SETG WINNER ,SCREENING-DOOR>
               <RTRUE>)
              (<VERB? HELLO>
               <SETG WINNER ,PROTAGONIST>
               <PERFORM ,V?HELLO ,SCREENING-DOOR>
               <SETG WINNER ,SCREENING-DOOR>
               <RTRUE>)
              (<AND <VERB? WHAT>
                <PRSO? ,OBJECT-OF-GAME>>
               <SETG WINNER ,PROTAGONIST>
               <PERFORM ,V?ASK-ABOUT ,SCREENING-DOOR ,OBJECT-OF-GAME>
               <SETG WINNER ,SCREENING-DOOR>
               <RTRUE>)
              (T
               <TELL
"\"Unless you're here to show me some clear sign of your intelligence, please
leave me alone. I'm a very busy door.\"" CR>
               <FUCKING-CLEAR>)>)
           (<AND <FSET? ,SCREENING-DOOR ,OPENBIT>
             <VERB? SHOW GIVE KNOCK OPEN>>
        <TELL "You already induced the door to open." CR>)
           (<AND <FSET? ,SCREENING-DOOR ,OPENBIT>
             <VERB? CLOSE>>
        <TELL
"The door snaps, \"Hey! I'm resting. I've had a very busy day.\"" CR>)
           (<VERB? KICK>
        <FSET ,SCREENING-DOOR ,MUNGEDBIT>
        <TELL
"\"I suppose you think that since you have legs and I have not, you can get
away with that sort of thing. Well,\" the door continues stiffly, \"maybe you
can and maybe you can't.\"" CR>)
           (<VERB? SHOW GIVE>
        <COND (<AND <PRSO? ,TEA ,NO-TEA>
                ,TEA-SHOWN
                <HELD? ,TEA>
                ,HOLDING-NO-TEA
                <NOT <PRSO? ,TEA-SHOWN>>>
               <PERFORM ,V?KNOCK ,SCREENING-DOOR>
               <RTRUE>)
              (T
               <COND (<PRSO? ,TEA ,NO-TEA>
                  <SETG TEA-SHOWN ,PRSO>)>
               <COND (<PROB 50>
                  <TELL
"The door says \"Big deal. Anyone can have">
                  <ARTICLE ,PRSO>
                  <TELL ".\"" CR>)
                 (T
                  <TELL "The door yawns." CR>)>)>)
           (<VERB? OPEN KNOCK>
        <COND (<AND <HELD? ,TEA>
                ,HOLDING-NO-TEA>
               <FSET ,SCREENING-DOOR ,OPENBIT>
               <TELL
"The door is almost speechless with admiration. \"Wow. Simultaneous tea
and no tea. My apologies. You are clearly a heavy-duty philosopher.\" It
opens respectfully." CR>)
              (T
               <TELL
"The door explains, in a haughty tone, that the room is occupied by a
super-intelligent robot and that lesser beings (by which it means you)
are not to be admitted. \"Show me some tiny example of your intelligence,\"
it says, \"and maybe, just maybe, I might reconsider.\"" CR>)>)
           (<AND <VERB? ASK-ABOUT>
             <PRSI? ,OBJECT-OF-GAME>>
        <TELL "\"To keep out sub-intelligent beings.\"" CR>)
           (<VERB? THROUGH>
        <COND (<EQUAL? ,HERE ,PANTRY>
               <DO-WALK ,P?EAST>)
              (T
               <DO-WALK ,P?WEST>)>)
           (<VERB? EXAMINE>
        <FCLEAR ,SCREENING-DOOR ,ACTORBIT>
        <V-LOOK-INSIDE>
        <FSET ,SCREENING-DOOR ,ACTORBIT>)>>

A few questions:
How does this code speak to the frustration-inducing nature of the game?
What does this code reveal about ZIL as a language?
Or does this code show that the game is just terribly misunderstood?
Is this a representative passage from the game?
How does this compare with puzzles of other Infocom games of the time?
What other passages of the HGTTG code should we explore?

Approaches to Co-Creation 
In this example, community-sourced data can be traced both visually and in code, and can be used to inform the very model used to process this information. Rather than simply coding, the prototyping process is incorporated in the code from a critical perspective. This process is guided by the Cultural AI Design Tool, which refocuses the design process so that questions of creator, data origin, and rule-creation are centered rather than marginally examined or ignored. Using these as a basis for this particular critical code context, contributors are credited, while also keeping the prototype open for co-creation and reformulation by the community.

Modeling Binaries: 
There are several pieces that contribute to Feminist Search: personal data donation, interface design, and the use of binaries in data collection and model creation.   

The Feminist Search project explores what is safe and what is dangerous. Binary notions of safety and danger are just the starting point. Within the last five years, rising dangerous rhetoric is becoming socially acceptable once more and a corresponding rise in violent acts globally. Beyond this, there are the pressures of misogyny, racism, and other forms of bigotry that increase an individual or community's constant awareness of action to make themselves safe. What makes people feel safe? Safety can be categorized differently, such as physical, emotional and professional safety. 

These binary definitions can be expanded by examining the grey spaces with the questions in the personal data donation. By having people discuss what safety means to them, or semantics of this term and related concepts, models can be built that reflect these spectrums, that allows for both exciting design and technical challenges, but more importantly, for creating technology that is for the people who contribute their data. Feminist Search explores the challenges of search from a community perspective---with a goal of reflecting the shared data of communities in Los Angeles and San Francisco. 

One highlight is that computation is fundamentally binary, as are labels in machine learning---the data donation portion of Feminist Search uses labels of safe and dangerous. However, the goal is to move beyond a true/false dichotomy, because truth value in subjective particularly in categorizations of feelings and sentiments.

For those who are not familiar with the details of machine learning, fundamentally, machine learning is mathematical representations of geometric spaces that have distance functions as part of their definition. In defining geometric  classes, there will be a division between classes in an n-dimensional space (as in linear regression), or instead perhaps something such as a centroid in a clustering algorithm that will be the most representational of a cluster. Prediction(s) as to a class or type of image will depend on the geometric location in the vector space of the item(s).  

The interesting problems in data science and machine learning aren't in churning out mathematically good predictions, however. The outcome of an algorithm is only as good as the data given to it and how the person(s) constructing it use that data in the creation of a model. What often happens in construction of models is that outliers from other data points are often thrown out or are drowned out in the majority vote of the more "normal" considerations. Thus, these lead to models where a literal tyranny of the majority can happen, since the majority of opinions have more weight statistically - instead of treating all the data equally. 

In this approach, the simple act of search can be used to understand binary decisions that are used to form a model, and how users can donate information to understand who is contributing to search and data collection. This is the central starting point that prioritizes visualization and creates a space to develop a community search engine. In Feminist Search, communities create and provide contexts for evaluation, with the goal of sharing these decisions along with donated personal data, and the "why" in the search results. 

An additional goal of Feminist Search is to highlight thoughtful data donation and model weighting processes, while also showing how search is used---thus incorporating Feminist.AI approaches by exploring the act of search by utilizing embodied, multi-sensory (movement, sound, and images) methods through critical prototyping. Feminist Search is a way to solidify and continually honor the work of feminist communities.

Here is the code for Feminist Search
Thompson, 2020, Python

import numpy as np
import cv2
import glob
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

def  import_image(path):
    """
    INPUT: path to image file in jpg
    OUTPUT: machine readable image file
    """
    image = cv2.imread(path)
    return image

class  ClusteredImages:
    def  __init__(self, positive_images_path, negative_images_path, image_suffix, number_of_clusters):
    self.positive_images = set(glob.glob(positive_images_path + '/' + image_suffix))
    self.negative_images = set(glob.glob(negative_images_path + '/' + image_suffix))
        self.no_of_clusters = number_of_clusters

    self.image_paths = [[path, True] for path in self.positive_images] + [[path, False] for path in self.negative_images]
        self.image_array = np.array(self.image_paths)
        
    self.descriptors = []
        for path, label in self.image_array:
            image = import_image(path)
            b_and_w = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            sift = cv2.xfeatures2d.SIFT_create()
        kp, each_descriptors = sift.detectAndCompute(b_and_w, None)
            self.descriptors.append(each_descriptors)

    def  return_labels(self):
        return np.array(self.image_paths)[:, -1]

    def  generate_features(self, clustering_model):
            # rename function to reflect that it returns both training data and predictable data
            number_of_clusters = clustering_model.n_clusters
        descriptors_pre_array = [desc for desc_list in self.descriptors for desc in desc_list]
            descriptors_array = np.array(descriptors_pre_array)
            clustering_model.fit(descriptors_array)
        clustered_words = [clustering_model.predict(words) for words in self.descriptors]
            return np.array([np.bincount(words, minlength=number_of_clusters) for words in clustered_words])

class  ParameterFinder:
        def  __init__(self, X, y):
            # use gammas for rbf, poly and sigmoid
            #degrees for poly
            self.X = X
            self.y = y
            self.kernels_to_try = ['linear', 'rbf', 'poly', 'sigmoid']
            self.C_params = [0.001, 0.01, 0.1, 1, 10]
            self.gamma_params = [0.001, 0.01, 0.1, 1]
            self.degree_params = [0.0, 1.0, 2.0, 3.0, 4.0]
        
    def  find_best_params(kernel, X, y, param_grid):
                grid_search = GridSearchCV(svm.SVC(kernel = kernel), param_grid)
                grid_search.fit(X, y)
                return grid_search.best_params_

        def  return_all_best_params(self):
            best_params = {}
                # should rewrite to pass kernel and find parameters
                for kernel in self.kernels_to_try:
                    if kernel == 'linear':
                            param_grid = {'C': self.C_params}
                            search_for_params = find_best_params('rbf', self.X, self.y, param_grid)
                            best_params['linear'] = search_for_params
                    elif kernel == 'rbf':
                            param_grid = {'C': self.C_params, 'gamma': self.gamma_params}
                            search_for_params = find_best_params('rbf', self.X, self.y, param_grid)
                            best_params['rbf'] = search_for_params
                    elif kernel == 'poly':
                            param_grid = {'C': self.C_params, 'gamma': self.gamma_params, 'degree': self.degree_params}
                            search_for_params = find_best_params('poly', self.X, self.y, param_grid)
                            best_params['poly'] = search_for_params
                    else:
                            pass
        return best_params

I’ve been looking through a copy of Jean Sammet’s Programming Languages: History and Fundamentals (1969), particularly the sections on string processing languages and specialty languages. The latter contains a description of Protosynthex, which is a language designed to be used for question answering tasks. I was curious about this language because I’m interested in the history of AI, and 1960s AI research seems to have been tied very closely to linguistics and logical reasoning - arguably much closer than it is today. The Protosynthex code example in Sammet’s book is quite short, and it’s been difficult to find more examples. I did manage to find some example uses of Protosynthex III in a research paper from 1970 titled ‘A Deductive Question-Answerer for Natural Language Inference’, by Schwarcz, Burger, and Simmons. I’ve taken screenshots of the example code in Example 3 and included it in this thread as a PDF. I've also included the paper, where the code can also be read from pages 181-182. It’s not clear to me whether Protosynthex III is a distinct language like Protosynthex is, or if it is actually a form of the LISP language.

What I find interesting about the example code in _Example 3 _ (pp. 181-182), which I’ll call ‘There is a Monkey’, is that it appears to play out a scenario which could be seen in an animal experiment. ‘There is a Monkey’ declares a monkey, a box, and bananas. The bananas are positioned in such a way that they are only to be reached if the box is moved TO THE BANANAS. Towards the end of the example code a query reads DOES THE MONKEY GET THE BANANAS?, with the final line of code stating MONKEY REACH BANANAS. . The paper states that this example is “...adapted from an Advice Taker problem proposed by [John] McCarthy” (p. 174) in his ‘Situations, actions, and causal laws’, found in Stanford Artificial Intelligence Project Memo No. 2, July 1963. McCarthy is the inventor of the LISP language, which has been historically very popular in AI.

There’s no background given about why or how the monkey, box, and bananas have been brought together, what their size and distance from each other is, why or how the bananas are suspended, nor any information about where this event or simulation is taking place. Indeed, we do not really know if (THERE . PLACE) on line 7 even has a floor or walls, but I suspect that most people who read this code will assume that the event or scenario is not taking place in a monkey’s natural environment (do you agree or disagree?). This event or simulation could have instead easily been written by declaring a climbing tree instead of a box, but for whatever reason a human made object is declared as the means or tool for reaching the bananas. This seems very unnatural, as if an animal is being observed and tested in an experiment environment in order to collect evidence or to prove something. Of course, the actual purpose of this code is to prove or demonstrate what types of question answering experiments can be conducted using Protosynthex III. However, this in itself does not explain why a linguistic and AI experiment is performed as an event or simulation set up in a minimal, controlled environment designed to test if a monkey will reach its food. I therefore find it curious that the emerging field of AI in the 1960s would reproduce controversial forms of experimentation as seen in biology and psychology in its models. Perhaps there is a prestigious ‘scientific aesthetic’ that is trying to be emulated. Perhaps it’s just following what is perceived to be a convention. Perhaps you can see other readings?

The paper offers its own explanation of ‘There is a Monkey’, which I’ve copied here:
“Explanation. The monkey gets the bananas if he reaches them, and he can reach them if he stands on an elevated object under them and reaches for them; the monkey stands on the box, which is an elevated-object, and reaches for the bananas, and so if the box is under the bananas the monkey has succeeded in reaching them; the box is under the bananas if it is lower than they, which it is, and also at the bananas; the box is at the bananas if some animal has moved it to the bananas--which of course the monkey has done; therefore, the monkey reaches the bananas. The question-answerer follows just this reasoning path in answering the question (though in terms, of course, of the formal concept structure) ; the recombination of subgoal answers into an answer to the question is shown by the trace of STOGOAL in the Appendix. It is interesting to note here, of course, the input of inverses (converses) and inference rules by means of English sentences; with a few additional grammar rules and pieces of lexical information, properties could be input in this manner also”(p. 176).

I have recently read Lillian-Yvonne Bertram's excellent new book of poetry, Travesty Generator. I started writing a short book review for CCSWG, but I just kept digging into it. So what follows is my hastily-written and barely-edited analysis of three of its poems. I'm interested in discussing this book and in whatever conversation my analysis/review may lead to here, but I mainly want to post this because I think this community will dig this book too and I wanted to make sure more people know about it.

What follows is pretty rough, so I will probably copyedit and refine it somewhat after posting.

Lillian Yvonne-Bertram's book of poetry is titled Travesty Generator (Noemi Press, 2019) in reference to Hugh Kenner and Joseph O'Rourke's Pascal program to "fabricate pseudo-text" by producing text such that each n-length string of characters in the output occurs at the same frequency as in the source text. By combining different authors through this algorithm, one might stumble across a travesty of "haunting plausibility" wherein James Joyce's writing becomes muddled with Henry James'. The pseudo-text's nonsensibility is simultaneously its transgression and its literary possibility, but for Kenner and O'Rourke and the many progeny of their program, those possibilities extend no farther than a formal curiosity or at best an insight into an author's poetic style.

When Charles O. Hartmann uses Travesty in his Virtual Muse, he finds that the nonsense it generates helps Hartmann's composition process by disrupting the habits he found himself following as a writer. Of the generator itself, Hartmann noted with some awe that "here is language creating itself out of nothing, out of mere statistical noise" (63).

What Bertram accomplishes in naming her book after travesty generator is to raise the stakes in computer-generated poetry. Whereas for Kenner and O'Rourke, labeling their work a "travesty" is a hyperbolic tease, a literary burlesque, for Bertram, the word is reinvigorated with a feeling of its political reality. In 2013, attorney Don West, responding to the not guilty verdict for his client George Zimmerman in the shooting death of Trayvon Martin, congratulated the jury for keeping "this tragedy from becoming a travesty." West is implying that the media attention on the case risked creating what he and Zimmerman would have called a farcical miscarriage of justice for his client.

"Counternarratives"

For others, the event was always a travesty: a "grotesque parody or imitation" of criminal justice enacted by a civilian playing at being a law enforcement officer that resulted in an extra judicial killing of an unarmed high-school student.

Central to anyone's response to that verdict is how one understand the narrative of events on February 26, 2012. This is question Bertam takes up in her poem "Counternarratives" which presents sentences, fragments, and ellipses that begin ambiguously but quickly resolve into a series of hints, implications, and images around Trayvon Martin's killing. These narratives are "counter" for several reasons, most importantly for the fact that they include Martin's point of view:

He never told anyone, but he always wanted to go to space camp.
...
He rides from station to station until he can rest at home.
...
Sometimes he wakes feeling gone and doesn't know why.

Bertram prints these sentences with others in 14 successive stanzas, each printed on its own face of a page, each growing in size until the blank 13th stanza breaks the pattern. One can see the inertia of automation and the inevitability of processes at work in the consistency of this pattern and in the way the poem intersects other perspectives that include the algorithmic prompts of search engines ("People also ask: what really happened?") and the horticultural ("Only the flowering catalpa trees are on watch") -- all echoes of the machinic "generator" in the book's title. But because this is literally generated from computer code, these observable processes yield two other significant "counters" at work.

Bertram does not share the source code for this poem, but in an appendix acknowledges that it is adapted from the Python version of Nick Montfort's poem, "Through The Park," published in his 2014 collection #! and available on his website. Montfort's poem is framed by a for loop, or a "counter," i, iterating through 8 sequences, each of which prints a numbered stanza:

for i in range(8):

For each loop and each stanza, the program selects a number 7 - 11 (phrases = 7 + random.randint(0,4)) and randomly deletes lines from the initial 25 unti the lines that remain reach the selected number of phrases, joining those remaining lines with ellipses. The resulting poems achieve their meaning through omission, elision, and innuendo, relying on the ambiguity of language and the way readers respond to that ambiguity by imagining the context that creates the poem's implied narrative. What that narrative is will depend on which lines end up being printed, and in #!, the 8 stanzas that Montfort selects show how widely those contexts may diverge, and these could range from a casually flirtatious encounter with a stranger to a sexual assault. The latter reading is activated by whether two or three key phrases are chosen to remain in the resulting poem. The suggestive phrases "The girl puts on a slutty dress", "The man makes a fist behind his back," "The man's breathing quickens," and "The man dashes, leaving pretense behind" makes "The girl's bag lies open" metonymic and lets the question of what their glances know "The man and girl exchange a knowing glance" hinge the meaning of the moment toward violence.

The girl puts on a slutty dress. ... A wolf whistle sounds. ... The muscular man paces the girl. ... A wildflower nods, tightly gripped. ... Laughter booms. ... A lamp above fails to come on. ... The girl's bag lies open. ... A patrol car's siren chirps. ...

This violence is implied, but generic, and the poem's meaning is about the way language gives shape to violence. The victim blaming in the "slutty dress" line, for example, is Montfort reminding us of the ways that words create an inertia of belief that precedes knowing. Ultimately, however, this is all that is stake for the poem.

Bertram's "Counternarratives" is more than an adaptation of Montfort's because it is also a counter to "Through the Park." Whereas the context for Montfort's poem is hypothetical, Bertram's is real and specific. While we cannot consult Bertam's source code, it is possible to imagine the process whereby Montfort's "A wildflower nods, tightly gripped" becomes Bertram's "The frangipani swans in the moonlight" and Montfort's "She puts on a slutty dress" becomes "People also ask what he was wearing." or perhaps "No mention of his clothing."

What Trayvon Martin wore -- a hoodie -- became a symbol for that event and a meme for Black Lives Matter because of its power in calling out racial profiling. The assumption that a "black man with a hoodie" is inherently threatening is conveyed in Bertram's "People also ask..." phrasing, which quotes a google search suggestion. In the context created by this poem, this question recalls the victim blaming in Montfort's poem's "slutty dress" line, but following Bertram's move from the generic to the particular, this search suggestion and other's like it are drawn from reality.

After a few trials, I discovered the suggestion "What was Trayvon Martin wearing?" in response to the search query "Who shot Trayvon Martin?". I also found another recurring line, and the final line in Bertram's poem, "People also search for: Emmett Till" come up in several similar searches. This is a demonstration of the way that search engines, like language, become the machinery for racial violence through their operationalization of algorithmic bias. Notably, Bertram's line does substitute Martin's name for the pronoun "he," so the antecedent could be Zimmerman, especially since neither are named outright in the poem. This final opening out of meaning is another significant way in which the poem reflects on its constructedness.

In the book's appendix, Bertram notes that the output of her program has been edited and arranged, and this rewriting is evident in the way that certain of the phrases evolve as the poem progresses. In some cases, this is an evolution that follows a trajectory implied to begin in Montfort's version which has its possible final line, "A patrol car's siren chirps."

Bertram's lines (never the last for any of her 14 stanzas) proceeds from there to

[3] ... A patrol car's siren sings several streets away...

[10] ... Several weeks away, a patrol siren sings...

[11] ... A patrol car's siren sings several streets way...

[12] ... A patrol car's siren swats bugs and halos away...

[14] ... A siren signs

several streets away.

The most striking movement in the poem is that way that "Counternarratives" uses ellipses. Whereas Montfort's poem is suggestive through the innuendo created by stochastic omission, Bertram's is subversive through the implications of its elisions, and those elisions and ellipses gradually resolve into prosodic syntax as the text of the poem gradually takes up its poetic mechanism. The phrase that first appears in stanza 4 as "Real gaps spread in the tropic of paradise" is stark in its proximity with its initial following line "Forty-two miles from Disney," where proximity here is both the poetic associations as well as the geopolitical identity of this Orlando suburb.

After the blank penultimate stanza -- a final elision -- this line has become "Gaps split open the tropic of paradise." A blank line splits the "siren signs" sentence, followed by the now damningly unambiguous "Cause of death: It was a gated community."

By editing and arranging the output of her program, Bertram is declining to let the machinery of language or Python control the narrative and opening up paths to resistance by insisting that we bear witness to the tragedy without retreating to the algorithmic distance of a travesty.

Two other poems in Travesty Generator offer similar insights on the relationship between the mechanization of computing and use those processes to interrogate the structures that make them possible.

"three_last_words"

The poem that opens the book, "three_last_words", is at a functional level a restatement of the program in Nick Montfort's "I AM THAT I AM", which is itself a version or adaptation of Brion Gysin's permutation poem of the same title. That phrase does not appear in Montfort's version. Rather, Montfort's program defines a permutations function and then executes that function with the string 'AEIOU' as its argument, yielding the 120 possible rearrangments of AEIOU as its outcome. Montfort's code accomplishes this succinctly through an elegant recursion as the permutations generator works through a list of elements, rearranging all of the following elements (elements[1:]) by passing them back into no more next elements remain.

"I AM THAT I AM" (from Montfort)

def permutations(elements):
  if len(elements) == 0:
    yield elements
  else:
    for result in permutations(elements[1:]):
      for i in range(len(elements)):
        yield result[:i] + elements[0:1] + result[i:]

Bertram's generator is mostly the same, code but the commentary she adds -- and more importantly the uses she puts it to -- changes the meaning entirely. That new meaning is jarring and, as in "Counternarratives," tragic.

Bertram alternates lines of code with comments that accumulate toward something unavoidable:

"three_last_words" (excerpt) (Bertram)

def permutations(elements):
#the
  if len(elements) == 0:
#the knife
    yield elements
   #the knife they
  else:
#the knife they hung

Eventually the completed sentences warns, "#the knife they hung him on / #was a legal trinket". When he was killed by Daniel Pantaleo while being placed under arrest, Eric Garner was selling loose cigarettes -- a minor violation of cigarette tax law. So "legal trinket" here brings to mind the way that Garner's alleged crime of selling cigarettes became a dog whistle for racist backlash to Black Lives Matter -- responses that included an Indiana police officer selling t-shirts with the mocking slogan, "Breathe easy, don't break the law." So a "trinket" because the relatively trivial infraction apparently justifies police violence.

"Trinket" does something else here as well, by naming a service, Trinket.io, which allows users to create snippets of Python code that they can embed and run in a webpage. This apparent reference hints at the practical environment for running this code, something that is unnecessary for Montfort's ontological poem because of its tautological symmetry.

Bertram's poem instead invites us to experience the consequences of her program with an explicit invitation a page later to

#run the code
    #in this cell
        #away

The "cell" here may connote a jail cell, but more practically it describes a Python Notebook cell. Python Notebooks are a common way to experiment with Python, and the samples of output and the poem's culminating error message are typographically consistent with with what one would see while running this code in a notebook.

Montfort's program runs one permutation and prints the output: 120 variations on the five vowels arranged from 'AEIOU' to 'UOIEA' in 8 tidy, monospaced columns.

Bertram's program runs three times, and whereas Montfort's final line of Python 2 code prints the permutated combinations as a string (print ''.join(list(permutations('AEIOU')))), Bertram's Python 3 simply prints the list as it is represented in Python's memory. The first iteration permutes a single-character:

print (list(permutations("I")))

['I']

In addition to this invitation to experience the practical implementation of the program, this different in printing the yield of the permutations function pulls us toward the subjective point-of-view of the Python runtime that experiences the code, and the chaotic typography of the output -- in contrast to Montfort's neat rows and columns -- performs the messy complications of computation that will eventually culminate in the runtime's demise.

There is one more subtle variation between Montfort and Bertram's code in the final line of the constructor. As it iterates through the elements list (a string of text characters, in this case) the newly-permutated line yields with + result[i:] for Montfort or + result for Bertram.

The functional difference is that Montfort's line restores to the target string only those parts of the input string that come after the character operating for the current iteration. The [i:] slice captures only those elements after i. Bertram's version retains and concatenates the entire working result, so the practical difference is that while Bertram's code will generate the same number of permutations, the strings it generates gradually become longer. The last element in the permutations of the string "can't" is "t'nact'nat'nt't". I see this introducing a measure of inexhaustibility. Whereas the 120 permutations of "AEIOU" are a complete and homogenous set, permutations("can't") is asymmetrical and growing. The articulation of print (list(permutations("breathe"))) runs past the right and bottom edges of the page.

The asymmetry culminates finally and dramatically with the full phrase "I can't breathe". Bertram's code concludes with the printout out of a Python MemoryError because the number of possible combinations of the 15 letters in that phrase (1,307,674,368,000) exceeds the available memory on the computer hosting the Python runtime, and like the 15 seconds that Officer Pantaleo held Eric Garner in a chokehold, those 15 characters result in the death of the Python Notebook or the computer hosting it.

I attempted to run Bertram's code two different ways: first in a Google-hosted Colab Notebook and later in a Jupyter Notebook running on my laptop. The Colab Notebook ran for some time with the RAM usage indicator creeping slowly to the right and becoming first green, then yellow, and finally orange before the runtime crashed and disconnected.

On my Macbook Pro, the results were similar, but as Python continued to take up more and more RAM, my computer gradually stopped working. The cursor slowed down, the trackpad clicked more slowly, and keyboard shortcuts stopped working. I couldn't take a screenshot, so I had to use another device -- my phone -- to capture the final moments before I resorted to a hard reboot and power cycle.

It seems trivial or maudlin to compare a computer running out of memory to the tragedy of Eric Garner's asphyxiation and death, but the way the computer's memory usage creeped steadily upward conveyed a vivid anxiety and sense of panic in a way that was hauntingly effective. This poem is directly addressing the physical environment of computing in a manner reminiscent to Montfort's poem "Round", or Sam Lavigne's parodic "Slow Hot Computer" project that "makes your computer run slow, and hot, so you can be less productive" by running "processor-intensive calculations" in a web browser.

This kind of metaleptical irruption of attention -- what Terry Harpold has called "recapture" -- is typically accomplished in the service of play, both in the satiric sense of Lavigne's playfully critical projects and, for Harpold, in both the literal sense of playing videogames and the semiotic sense of expressive freedom within constraints. In Montfort's examples, recapture moderates the conflicts of entanglement with technical limitations are expressed through the terms of the gameworld, as when a text-based game attempts to parse an unknown word of user input and it replies "I didn't quite understand that" instead of reporting an error code or just crashing. Recapture is fundamental operation of videogame, which means that "recapture happens during play, in the complex digressions and feedback loops that are activated in actual play."

Bertram's works withe same entanglement of technical process and expressive semiotics, but poetry is not a videogame, and in this case, the poem denies its reader the recapture of memory, challenging us instead to bear witness to the trauma it represents.

As Wendy Hui Kyong Chun has discussed, computer memory is an "enduring ephemeral," always-already conflating memory with storage and, through metaphors and pretenses of permanence. She notes that the instability of this term, memory, follows the volatility of RAM, which is "based on flip-flop circuits and transistors and capacitors" and which require a steady electrical current" (169). Like human memory, software "memory is not a static but rather an active process. A memory must be held in order to keep it from moving" (167). Bertram's software presents the volatility of memory as the entanglement of poetic representation, police brutality, and technical limitation, and by setting it up to fail, Bertram invites us to reenact the trauma of that brutality and interpret its technical and political consequences.

When Bertram disrupts the symmetry of Montfort's slices (result[:i] and result[i:] becomes result[:i] and result so that "ehtaerb" potentially becomes the drawn-out, Joycean susurration "ehtaerbehtaerehtaeehtaehtehe", that is, print(list(permutations("breathe"))[-1])), but both versions of the generator choke on Eric Garner's three last words. Memory fails, but the poem preserves its failure even as its overflow suggests a world uncontemplated by code. This overflow is not infinite -- hinting that someday, when it becomes possible to run this program with the multiple terrabytes of RAM necessary to compute and convey one trillion three-hundred seven billion six-hundred seventy-four million three-hundred sixty-eight thousand lines, the program will complete, but until then we are compelled to follow Bertram's invitation to bear witness and

#return
    #this articulation
#the exhaustion
    #we can't stop hearing

A NEW SERMON ON THE WARPLAND

Like "three_last_words" and "Counternarratives," "A NEW SERMON ON THE WARPLAND: a poem by algorithm" is a work with a genealogy, and Bertram directs us to the source codes that ground it. This is another poem where Bertram gives credit to an example by Nick Montfort, but his code is a straightforward implementation of Alison Knowles' "A House of Dust," so Knowles is the more appropriate counterpoint for Bertram's work. More significantly, Bertram acknowledges "that some words and phrases ... are taken directly from Gwendolyn Brooks' corpus" in her notes, so understanding those origins allows these phrases to act hypertextually as a bridge into Brooks' poems. Bertram encourages us to explore that bridge by recommending Brooks' 1987 collection Blacks, and specifically points to "The Sermon on the Warpland" and In the Mecca as especially important sources. ("Boy Breaking Glass" and "THE WALL" also seem to be the sources for several phrases.)

Alison Knowles and James Tenney produced "A House of Dust" in 1968, the same year that Gwendolyn Brooks published In the Mecca. The source code for "House of Dust" is not publicly available, but its function is easy to deduce by examining the output published in three different venues. Knowles created the structure and four lists of words and phrases, and Tenney wrote those into FORTRAN code that creates quatrains by selecting and printing one item from each list, indenting each line a few spaces before returning to left justification as each new quatrain begins.

A HOUSE OF ROOTS
    AMONG HIGH MOUNTAINS
        USING NATURAL LIGHT
            INHABITED BY VARIOUS BIRDS AND FISHES
A HOUSE OF WOOD
    BY A RIVER
        USING ALL AVAILABLE LIGHTING
            INHABITED BY HORSES AND BIRDS
A HOUSE OF DISCARDED CLOTHING
    UNDERWATER
        USING ELECTRICITY
            INHABITED BY FRENCH AND GERMAN SPEAKING PEOPLE

When I created a simulation of this poem in Javascript, I named these lists materials, places, lights and inhabitants. Montfort used the names material, location, light_source and inhabitants.

Bertram doesn't share her code in Travesty Generator, but observing its patterns reveals it to have a similar structure of lists randomly sampled. Also, two earlier versions of Bertram's "A NEW SERMON ON THE WARPLAND" are available online, one in Javascript (https://ruby-buffet.glitch.me) and another in Python 2 (https://www.lybetc.tech/new-sermon-code). In the Javascript version, each list simply bears a number (one,two, etc.), but the Python 2 version assigns names that signpost the function of each list. There are differences between the source code shared on Bertram's website and the code that created the poem published in Travesty Generator, but the five names suggest their content and reveal Bertram's primary departure from Knowles: materials, locations, verb, means, and outcome.

A NATION OF GRIEF
               IN THE CUT
    SUMMONING
                    ANY MEANS NECESSARY
TO REFUSE ERASURE BY ALGORITHM
A NATION OF OLD DISPOSSESSIONS
               STILL FIGHTING
    CONJURING
                    ANY MEANS NECESSARY
TO REVISE ERASURE BY ALGORITHM

Comparing "House of Dust" with "NEW SERMON" reveals more differences than the addition of a fifth line. Knowles' locations are diverse but more stable -- "BY THE SEA", "IN MICHIGAN", "IN A HOT CLIMATE", "ON AN ISLAND","IN SOUTHERN FRANCE","AMONG OTHER HOUSE" -- while Bertram's are active, violent, or disrupted, and some are not conventionally "locations" but moreso describe liminal states of being:

...IN THE CUT...
...STILL FIGHTING...
...IN FRONT OF A WINDOW ABOUT TO BE BROKEN...
...IN TRANSLATION...
...BETWEEN SCYLLA AND CHARYBDIS...
...IN THE SHIP'S HOLD...

Instead of a house, Bertram addresses her sermon to a "NATION". Allusions to the slave trade are perhaps most striking in comparing the subtle differences in phrases between Knowles' "ON THE SEA" and Bertram's "ON SHIPS", but the shifts in Bertram's poem is much more than a inversion of Knowles'. While "A House of Dust" dwells, a NEW SERMON moves, acts, and resists. The verbs and means lists propel each cinquain through the same means -- "ANY MEANS NECESSARY" -- to the same outcome: TO REFUSE ERASURE BY THE ALGORITHM.

The earlier Python 2 version includes multiple possible outcomes, but the verbs list is somewhat shorter. Because the printed version of the poem includes the same outcome in each cinquain, it is reasonable to infer that its source code is closer to the Javascript version where list five only contains one element, to refuse erasure by the algorithm. The means list works the same way, demonstrating that the only option is Malcom X's ANY MEANS NECESSARY.

For both of these one-choice lists, the program is still selecting that choice as the result of a process. The Python 2 draft uses the common random.choice() function, and the Javascript version takes a custom function with a comment remarking on its conventionality:

// This is a very common randomizing function.
// It takes a list (array) and returns one at random.
function select_random(x){
    y = x[Math.floor(Math.random()*x.length)];
    return y;
}

The fact that this program is making a choice with no freedom plays into the slavery imagery within the poem, but revisiting "A House of Dust" opens another way of understanding the significance of this choice without a choice.

Benjamin Buchloh argues that Knowle's project in creating "House" was to find a way to deconstruct the "prison house of language". Noting the irony of an avante-garde artist like Knowles using a house, that most conventional vehicle for subject formation, as her central figure, Buchloh contends that the aleatory construction method of the poem demonstrates the infinite fluidity of the process of subject formation.

Channeling Nietzsche, Buchloh goes on to observe that the constructedness of "House of Dust" resists the subject's being at "home" in language. "Knowles's The House of Dust conceives of the process of subject formation as a perpetual process of construction and undoing, precisely to prevent it from becoming an inhabitant of the prisonhouse of language, a merely substitutional system of fraudulent and agressive convictions...the formation of of the subject at this point in history has become a more complex and, by necessity, a more open process, since the subject's intersections with language...are certainly no longer the primary ... foundations". Buchloh's "convictions" are a play on words, a synonym for "belief" in the mode of the metaphoric correctional system. But it also opens up another angle on "NEW SERMON," which is filled with punishment and captivity but conspicuously without conviction.

Although the Javascript version of the poem does include "of parolees" and "of prisoners" as possible materials, possibly drawn from Brooks' "The Wall", the printed poem's materials and locations invoke punishment without the framework of judicial justification:

...A NATION OF SPECIFIC CHAINS...
...IN THE SHIP'S HOLD...
...A NATION OF MEDGAR EVERS...
...IN A STRING-DRAWN BAG...

In this way, Bertram's poem comes back to the prison house of language that Knowles' is playfully resisting. Captivity and imprisonment are not just metonymic critiques for the post-structuralist decentering of lexical epistemology; instead, the prison house of NEW SERMON is the literal kidnapping, enslavement, and genocide of Africans whose exploitation built the foundations of this nation.

Finally, by naming one of the lists verbs, Bertram follows a schema one often finds in generative works that use context-free grammar: patterns or templates where words are given a syntactical place based on their part of speech. In NEW SERMON, the verbs list does the most work to take the poem away from its origins in "House of Dust". The seven verbs that appear in the 22 printed cinquains all suggest movement with resistance or a sense of bring something out from below:

DIGGING UP
SUMMONING
CONJURING
DIVINING
UNEARTHING
STRIKING MATCHES AGAINST
HOLLERING DOWN

Each of these verbs immediately precedes "ANY MEANS NECESSARY". So, by omitting the preposition "by" from Malcom X's well-known phrase, the call to action in the poem asks its reader to dig up, to unearth, strike matches against their own means of refusing erasure.

In an appendix on the book, Bertram quotes Harryette Mullen's essay "Imagining the Unimagined Reader," "When I read words never meant for me, anyone like me ... then I feel simultaneously my exclusion and my inclusion as a literate black women, the unimagined reader of the text." Bertram likewise considers herself an "unimagined coder."

I use codes and algorithms in an attempt to create work that reconfigures and challenges oppressive narratives for Black people and to imagine new ones. I consider this an intervention into a set of literary practices that have historically excluded women and minorities.

For each of the works I have analyzed here and for many others of 10 poems in Travesty Generator, Bertram uses the generators of computer-generated poetry to critique, resist, and replace narratives of oppression and to make explicit and specific what is elsewhere algorithmically insidious and ambivalent.

Lillian-Yvonne Bertram's Travesty Generator is a challenging, haunting, and important achievement of code poetry.

Feminist Legacy and Theory
As long as there has been code there have been feminist approaches to coding and pattern finding---such as the first complex program which was created by Ada Lovelace in the 1840s, as well as the use of knitting for encoding secrets during World War II, often hidden in plain sight and overlooked for its perceived lack of value.

As artificial intelligence developed in the latter half of the twentieth century, most of its theorists and developers were overwhelmingly white and male. The roots of Feminist AI can be traced to contemporary theorists like British academics Alison Adam and Lucy Suchman. In Alison Adam's Artificial Knowing, she critiques traditional AI as symbolic and connectionist, both of which fail to address embodiment in the production of knowledge. Referencing Tong (1994) and Wajcman (1991), Adam argues that technology is inherently social, political, and cultural in its usage and production and that AI research can and should be informed by feminist theories such as liberal feminism, eco-feminism, postmodern feminism and standpoint theory. Additional Feminist theoretical approaches include participatory (BardzelI), embodied (Blumenthal), implementation into practice (McPherson), and design as research (Burdick). These approaches examine the mutable relationships of form, making, theory, and community.

Feminist Practices and Projects
Building on earlier work, new critical approaches and projects have emerged in recent years, including volumes on racism and feminism such as Safiya Umoja Noble's Algorithms of Oppression, Cathy O'Neil's Weapons of Math Destruction, Joy Buolamwini's Algorithmic Justice League and Catherine D'Ignazio and Lauren F. Klein's Data Feminism. Additional feminist projects which explore the role of the body in knowledge production, critical prototyping, and critiques of science and technology include Ursula Damm's generative video project Membrane, Wekinator by Rebecca Fiebrink, design approaches from Feminist Internet.com, Feminist Internet.org, LAUREN by Lauren McCarthy, Anne Burdick's digital humanities design fiction Trina, Gender and Tech resources project by Tactical Tech, ladymouth by Sarah Ciston, Catherine Grffiths' Visualizing Algorithms, and Caroline Sinders' work on the Feminist Data Collection, which details a path for building data collections and ontologies in a feminist reference and framework.

The organization Feminist.AI (to be distinguished from the conceptual approach Feminist AI) is a collective based across three cities (LA, SF, and Holdenville, OK) which strives to redefine AI from its current development in private companies and academic settings to community and socially-driven futures. Feminist.AI is developing a project called Feminist Search that explores many of the issues and approaches of Feminist AI practices through community-driven research and prototyping. Feminist Search is used to actively highlight the work of feminist theorist Dr. Safiya Umboja Noble, and her book Algorithms of Oppression. 

Feminist.AI Project: Feminist Search (Searching for Ourselves) 
Feminist.AI emphasizes and employs critical prototyping, participatory focused approaches (BardzelI), acknowledging creators, de-centering the human (Adam, Hayles, Braidotti), and viewing embodiment as beyond the enfleshed, as a body-self---living and indefinite (Blumenthal). Feminist.AI is an explicitly feminist practice and this value appears in our projects, including the recent offering Feminist Search, which involved co-creating a Feminist Search Engine. Sarah Ciston has written elsewhere in more detail about bringing intersectional methodologies to artificial intelligence.

Feminist Search addresses this multi-faceted approach to search and offers visual entry points as a starting place. It requires participatory engagement and critical prototyping. Feminist Search also engages the challenges of working within a binary, asking how that construct impacts the weighting and utilization of specific models, as well as how the interface design can highlight data bias or community contributors.

Search is one of the most commonly-used algorithms in the world and it is dominated today by several large private corporations, most notably Google. Google's search algorithm is driven by a combination of usage and ad revenue. The first Google search algorithm, PageRank, was used to measure and prioritize websites ranked according to a number of factors, and a more recent explanation is detailed in the video "How Google Search Works (in 5 minutes)."  To summarize, a search engine is comprised of a database (which can include things like images, webpages, videos, pdf's), and algorithms that interact with information on the web (such as text, metatags, links).  When searching, software is used to enter in a text based query and results are returned via text, voice or images. Search engines use web crawlers (spiders, spiderbots) to collect information about pages. These crawlers summarize links, tags, metatags and share information with the search engine. These "spiders" crawl across these pages to do several things---like find new content, index information, and rank. There is no human intervention---these algorithms are deployed in real time to gather information.

While these explanations clarify the process somewhat for the non-expert, they do not address the problematic features such as those covered by Safiya Umoja Noble, beginning with her 2012 article Missed Connections: What Search Engines Say About Women. In both this and her 2018 book, Algorithms of Oppression, Noble discusses the troubling intersection of search results and Black bodies, including returning a page of primarily pornographic pages when entering the term "black girls" and on results for searches for professional hairstyles returning pictures of primarily white women. Additional problems with web search involve indexing algorithms and filter bubbles. Specifically, information is linked, indexed, and personalized using factors and decisions that are not transparent. Professor Noble highlights the lack of review process for determining what is hyperlinked (Noble 41). Unwanted bias can also occur with filter bubbles which can serve up narrow information in personalized search.

Starting with a visual search prototype that uses community sourced images, Feminist.AI will build a larger visual search engine powered by community definitions and informed by library science and critical theory. With a belief in users as not only contributors, but also as owners of their experience and information, an editable, co-created search tool will be developed where users have control over access to their information and how it is used for development. Using this as inspiration, the Feminist.AI community proposes to create an alternative to private search engines with the working title Feminist Search.

Feminist Search seeks to add transparency to the search process and promote education about factors that determine how search results are created. The project creates multiple entry points for community members to learn about how information is classified, trained and accessed, making search more understandable and accessible. In our next post, we will go further into details of the Feminist Search project.

Critical Questions:
1 - How do engaging feminist principles and practices around embodiment, community, and critical prototyping shift how code might be read or written? How do they shift how you understand or engage AI more broadly?

2 - Historically, the contributions of female-identified persons has often been overlooked in the main narratives of events, as seen in the stories of one of humanity's most famous scientific achievements - the Moon landing in July 1969, or in the algorithmic processes of weaving or knitting. How can we reframe and revaluate traditionally "female" practices in light of today's emphasis on STEM education and create feminist spaces for both learning and developing coding practices?

3 - Can we imagine different sensory approaches for querying information? Currently, we use computers, with typing, voice search, and touch on screens. Could we simply improve our screen interfaces to incorporate new visual and interactive models of knowledge? How might we synthesize human and natural environments through search? How can we incorporate culturally specific ways of exploring knowledge through artifacts?

Contribute to this research!
We invite you to contribute to this research. We are currently seeking data donations for our Feminist Search prototype. You may donate your data here: https://aidesigntool.com/feminist-search

Thank You CCSWG 2020 community: Mark Marino, Jeremy Douglass, Zach Mann.

The story
In late 2015 I wanted to contribute to the work done in the hacking of FPGAs, in particular to project IceStorm. Back then I was in the middle of writing my PhD and I needed a break for a couple of days after getting one of my chapters rejected for the third time. Contributing to an open source project felt like a great way to recharge batteries.

For those not informed about the development of those tools. Field programmable gate arrays (FPGAs) are chips with no pre-loaded computing architecture. Microcontrollers, for example, come with a pre-loaded CPU, programs can be written on top of the CPUs commands. FPGAs allow to create your own CPUs. FPGA vendors' business consist in selling not just the chips, but also the programming tools (SW + HW), and development kits. Therefore, opening up any part of the process (as in open sourcing) is considered bad for business, since there is some money that will be made by someone else instead of the vendors.

A couple of years ago, and thanks to the effort of Claire Wolf (creator of IceStorm), several tools emerged that allowed creating code for a specific brand of FPGAs. Reverse engineering the bitcode to the FPGAs they opened for the possibility of people writing their own IDEs to create their own computing architectures.

I decided to contribute to this project because I knew one of the main contributors to the examples around IceStorm and creator of the Alhambra board, Juan Gonzalez Gomez, aka Obijuan. I looked at making the installation of the software and Obijuan's examples easier for those not speaking English, by creating the following repository:

https://github.com/dcuartielles/open-fpga-install/

In order to make this happen, I used the following article from 2010 on how to localize bash scripts:

https://www.linuxjournal.com/content/internationalizing-those-bash-scripts

The work done here was based on the idea that people should have an easy time installing from CLI and that having all of the messages in their own language should reduce the friction in that process. It took two years before I got a comment on how to improve the software (and I didn't notice until I started writing this post, 2 years later).

The mechanism for doing the BASH translation is done through calls to

i18n_display "your text string here"

The text string will be translated -on the fly- by taking it from the localization files under the translations subfolder.

The structure of those translation files looks as follows:

There you can see how msgid indicates the identifier to the string to be translated, while msgstr is the string in the translation language.

The questions

Years after having made this work, and despite its little success, I still wonder about the pedagogical value of prompting people about what is that their installation scripts are doing when installing things. If I create a tool and want to deploy it, I could write an article on my blog and explain the step by step operations needed to install all of the dependencies needed, or I could write a good BASH script that could be taken over others and translated to multiple languages.

• Do you feel, like I do, that CLI is coming back and that it is not that crazy to make the whole installation as a script, so that the actions and the documentation can be put in a format where it is easier to contribute to?
• Which are the limitations offered by the sharing interface (Github in this case) towards other communites, how would a translation process look like?
• Should it be workshops with potential community participants?
• Would you, as a user of one of BASH scripts, find useful to understand what happens when you call the different actions? Or would you prefer a non-running environment (like a blog) where to read about it instead?
• Have you ever installed a series of packages from CLI? How was your experience?

Recommended readings

In the beginning there was the command line by Neal Stephenson

Project IceStorm: http://www.clifford.at/icestorm/

Clifford on programming style: http://www.clifford.at/style.html (could be enough for another post)

How does a poet end up thinking in terms of algorithms, programming languages, and datasets?

I’m interested in exploring the work of writers of electronic literature who, instead of writing sequences of words directly, create a computer program or modify an existing one to generate their intended texts.

The practice of creating and repurposing “engines” encourage the development of born-digital poetic forms, such as Nick Montfort’s poem, “Taroko Gorge” which has been remixed hundreds of times since its publication in early 2009.

My notion of distant writing inverts Franco Moretti’s concept of distant reading, which is in turn a counterpoint to the hegemonic concept of close reading, by applying it to writing. With close reading we pay careful attention to a (presumably carefully chosen) sequence of words (let’s call it close writing) to draw meaning and insight from it— much of what we’re doing here at the CCSWG. With distant reading, Moretti invites us to develop tools and methods to examine large literary corpora to find patterns and insights about literary texts and movements. Distant writing subverts the notions of subjectivity, intimacy, and proximity in the Romantic vision of a writer who painstakingly chooses and arranges words in intended sequences. Distant Writing is about writers who create and implement algorithms to produce texts that achieve their goals.

We can extend the metaphor by conceptualizing varying distances between the writer and their text depending on how much control over the inner workings of the textual generation process the writer has. Here are some case studies, from short-distance to long-distance writing.

Short Distance Writing

Nick Montfort is well known in this community as a writer of generative works. Most of his oeuvre consists of carefully crafted minimalist generative literature. The openness of the MIT License these works are published in, and the versatility of his programming has encouraged others to remix and repurpose his works, as has been the case with “Taroko Gorge” (2009). For the code study, I want to present something more recent, his Nano-NaNoGenMo (NNNGM) novel consequence (2019). Here’s the code (in Perl) in its entirety:

perl -e 'sub n{(unpack"(A4)*","backbodybookcasedoorfacefacthandheadhomelifenamepartplayroomsidetimeweekwordworkyear")[rand 21]}print"consequence\nNick Montfort\n\na beginning";for(;$i<12500;$i++){print" & so a ".n;if(rand()<.6){print n}}print".\n"'

When you run that code in a terminal window, you get output like this.

consequence
Nick Montfort

a beginning & so a doorword & so a door & so a lifeweek & so a bodyname & so a handface & so a liferoom & so a nameplay & so a handdoor & so a time & so a bookplay & so a backcase & so a nameplay & so a caseweek & so a name & so a life & so a casepart & so a homeroom & so a doorword & so a book & so a yeartime & so a book & so a namehome & so a time & so a hand & so a lifefact & so a doorpart & so a work & so a roomlife & so a sideyear & so a yearhome & so a nameroom & so a part & so a roomfact & so a fact & so a handbody & so a workhand & so a timefact & so a playwork & so a homebody & so a headbody & so a homeback & so a headplay & so a bookwork & so a time & so a door & so a partbody & so a bodyhand & so a home & so a wordyear & so a play & so a room & so a facehead & so a head & so a roomdoor & so a hand & so a word & so a workside & so a caseweek & so a word & so a case & so a bodydoor & so a face & so a backwork & so a fact & so a timeface & so a yearcase & so a case & so a factplay & so a life & so a namename & so a time & so a fact & so a door & so a part & so a bodybody & so a faceyear & so a week & so a face & so a book & so a face & so a door & so a hometime & so a wordpart & so a lifeyear & so a weekyear & so a casebody & so a nameside & so a back & so a partdoor & so a sidebook & so a backpart & so a weekbook & so a part & so a

You can read the blog post about it here.

Some comments to get the conversation started:

• Part of the NNNGM constraint is to produce a 50,000 word novel (in the NaNoGenMo tradition) but with the added constraint of doing so with a program that is at most 256 characters.
• Montfort is experienced with this 256 character constraint, and created a series of generative poems titled ppg256 (2007-2012) where he developed the word compounding technique he uses here and in "Sea and Spar Between" (2010).
• By using exclusively 4-letter words, he was able to create a data set that could output common words and more poetically charged compound words. The constraint, which is very Oulipian, also a neat mechanism for code compression.
• The title, consequence, gestures towards that minimal foundation for plot--events connected by causality-- which is established by the connectors "& so a" in this novel. One thing leads to another in consequence all the way to its final period.

As distant writing goes, this is at a metaphorically short distance because the whole work is produced from this minimalist code and self-contained data set. Nick can manipulate the code and data set until it produces the output that fits his creative vision. Let's take another look at a similar, but more distant kind of writing.

Medium Distance Writing

OB-DCK; or, THE (SELFLESS) WHALE (2019) is also a NNNGM entry by Nick Montfort that transforms Herman Melville's Moby Dick into a version that removes all first person pronouns to remove the self, and the very narrator, from the novel.

Here's the complete code, though one must first download the text from Project Gutenberg and put it in the same directory you will be running the perl script from in a terminal window:
perl -0pe 's/.*?K/***/s;s/MOBY(.)DI/OB$1D/g;s/D.*r/Nick Montfort/;s/E W/E (SELFLESS) W/g;s/\b(I ?|me|my|myself|am|us|we|our|ourselves)\b//gi;s/\r\n\r\n//g;s/\r\n/ /g;s//\n\n/g;s/ +/ /g;s/(“?) ([,.;:]?)/$1$2/g;s/\nEnd .*//s' 2701-0.txt

Here's some of the output it generates:

Epilogue

“AND ONLY ESCAPED ALONE TO TELL THEE” Job.

The drama’s done. Why then here does any one step forth?—Because one did survive the wreck.

It so chanced, that after the Parsee’s disappearance, was he whom the Fates ordained to take the place of Ahab’s bowsman, when that bowsman assumed the vacant post; the same, who, when on the last day the three men were tossed from out of the rocking boat, was dropped astern. So, floating on the margin of the ensuing scene, and in full sight of it, when the halfspent suction of the sunk ship reached , was then, but slowly, drawn towards the closing vortex. When reached it, it had subsided to a creamy pool. Round and round, then, and ever contracting towards the button-like black bubble at the axis of that slowly wheeling circle, like another Ixion did revolve. Till, gaining that vital centre, the black bubble upward burst; and now, liberated by reason of its cunning spring, and, owing to its great buoyancy, rising with great force, the coffin life-buoy shot lengthwise from the sea, fell over, and floated by side. Buoyed up by that coffin, for almost one whole day and night, floated on a soft and dirgelike main. The unharming sharks, they glided by as if with padlocks on their mouths; the savage sea-hawks sailed with sheathed beaks. On the second day, a sail drew near, nearer, and picked up at last. It was the devious-cruising Rachel, that in her retracing search after her missing children, only found another orphan.

It is discussed in the same blog post I cited earlier, available here.

Some comments:

• By detecting and eliminating all personal pronouns from a novel narrated in the first person, Montfort has almost completely deleted Ishmael from the narrative. Clearly, "one did survive the wreck," but who exactly? Who is this narrator that tells the story of these colorful characters, Ishmael, Ahab, Queequeg, and a white whale?
• This kind of operation upon a novel hearkens back to Oulipian operations (such as the N+7 process, in which they would substitute nouns in a text with the seventh word that followed it in a dictionary to create a poetically distorted text), and is also firmly in the NaNoGenMo tradition, which draws heavily from Moby Dick.
• This program only produces one output from a text, though it could be used on other texts.
• The greater distance comes from the fact that it is built upon a text written by someone else. Montfort can modify the program to produce results that better achieve his artistic goals, but he can't change the main data set and still say it's Moby Dick.

Long Distance Writing

With long distance writing, the author either has limited control over the engine or the data set. I will not offer a code sample for long distance writing because, in most cases, it is either unavailable or impractical, but here are some examples and thoughts.

• Two of my favorite Twitter bots, @Pentametron by Ranjit Bhatnagar and @HaikuD2 by John Burger, search through the Twitter stream for tweets that happen to be in iambic pentameter and rhyme before retweeting them together or that could be cut into the shape of a haiku, respectively. One could argue that Bhatnagar and Burger haven't really written anything, and have only created the programs to distill rhyming couplets and accidental haiku from Twitter, but that would feel somehow unfair to the wonderful texts their bots produce. Their intent, craft, and execution results in works that wouldn't have existed without their vision, and that constitutes authorship, as far as I'm concerned.
• Bhatnagar's 2018 book Encomials: Sonnets from Pentametron explores the concept further by using different formal constraints to produce more complex poetic structures drawn from the raw material detected by @Pentametron. These feel less distant than his original bot, because we see Bhatnagar making more deliberate choices and refining his programming to produce output that more closely achieve his vision.
• Another popular method consists of training a Markov chain generator, neural network, AI framework, or chatterbot with texts and then prompting them to produce output based on the probabilities they detect. This year's NaNoGenMo featured several works that used GPT-2, an open AI framework. The authorial impulse is to train the frameworks, many of which operate as black boxes, to produce the kinds of output one desires.
• An example of this is The Orange Erotic Bible (2019), an anonymous work generated by the GPT-2 framework trained on a corpus of erotic literature and the King James Bible to produce erotic texts in the biblical tradition. You can see the code, corpora, and generated novel (Bible?) in the Github issue. The distance between the author and the text produced is substantive-- they didn't write any of the source texts, and performed limited operations on the output. Yet the results are so hilariously NSFW that I understand why the author chose anonymity to put some additional distance between themselves and the work.
• This tweet refers to a case of distant writing (of a bot powered character) that feels most removed from the authorial team (Google?) than all the previous cases. Here we have the distance of corporate authorship (Google's AI team) and a chatbot whose operations are hidden in a hardware and software black box. The only information that achieves escape velocity from this corporate black box is news of the effort, resources, and processing feats achieved.
  

Closing In on Distant Writing

Now that I've introduced the concept of distance from one's writing and shared some examples, I invite commentary and critique: of the concept, the examples, and the code provided. I hope this generates some conversation!

While human readers have a high tolerance for elision, for swapping of letters, or missing symbols, programming languages generally have no tolerance for this. The history of obfuscated code and of esoteric programming languages are breaks from clarity of presentation -- but the code itself is exacting and precise. Entries to the IOCCC, the International Obfuscated C Code Contest, look random or scrambled. However, to actually run as C programs means that behind their seeming chaos is the same compulsive approach to code.

I developed FatFinger, a dialect of JavaScript, to challenge this approach. FatFinger allows misspellings and typos as valid code. To get an idea of how this looks, here is a 99 Bottles of Beer program in FatFinger:

<script type="text/javascript" src="fatfinger.js"></script>
<script type="text/javoscript">
    var bottles;
    for (var counter = 99; counter >= 1; counter = counter - 1) 
    {
        if (counter == 1) {
            botles = 'bottle';
        } else {
            bottles = 'bottles';
        }
        constole.log(counter+" "+ bottless +" of ber on the wall.");
        if (countr < 99) {
            conssole.lg("");
            consoles.logg(counter+" "+ botttles+" o beer on the wall.");
        }
        conable.log(counter+" "+botles+" of beer.");
        console.lo("Take one down.");
        console.log("Pass it arund.");
        ift (ount == 1) {
            console.log("No botles of beer on the wall.");
        }
    }
</script>

The counter and bottles variables are both explicitly declared with var. FatFinger, unlike regular JS, requires explicit declaration because it will assume implicit variables are actually misspelled variables declared earlier.

bottles is variously written as botles, bottless, botttles. Even built-in JavaScript objects like console can also be misspelled, here as constole, connstole, and conable. The sloppy work seeps into the strings themselves, so it is not printing "No more bottles of beer on the wall." but actually "No more botles".

To get this script to execute as FatFinger in the html page, we have to first include the fatfinger.js library, and then put our FatFingered code within a script tag with any misspelling of JavaScript (here "javoscript" on line 2).

Behind the scenes, of course, FatFinger needs to turn this into functioning JavaScript that will run in the browser. It does this by finding identifiers that it can't identify and comparing them to a list of everything in scope. It uses Damerau–Levenshtein distance to find the closest match. This is the minimum number of operations (consisting of insertions, deletions or substitutions of a single character, or transposition of two adjacent characters) required to change one word into the other. So each unknown identifier is transformed into the one with the closest-matching name.

While this project had to be written in JavaScript -- the most chaotic of widely used languages -- it caused an issue in that building a list of what's in scope is not so easy. JS doesn't have a fully developed system of reflection -- the ability to read its own metadata and inspect itself -- that Java or C# does. In the buildLocalIdentifiers method we can see how this is done, with all the FIXMEs about scope issues. It begins with this comment:

// FIXME: there no scope and it doesn't even know if a var has been declared yet or not.
// Perhaps capture line numbers where things are declared and use the tree (since at this stage we can generate one) to help with 
// scope? However, public/private is tricky in js and there are cases where you can refer to things that are not yet declared

For the moment, these are mostly settled with a warning that "FatFinger has a poor concept of scope, so if you're doing fancy OO stuff, ask yourself: is there a good reason I haven't made everything global??? If not, this might not be the right library / coding style for you."

Programs in Cree# are told as stories, connecting with the Cree tradition; the graphical output can’t exist without the story that the code is telling. A Cree# program is also a multimedia story. In the above example, we have Raven (the Trickster), a character from Cree folklore who is as well known for his mischievousness as he is known for his role as a teacher and a guide. The program initializes when Raven flies on to the screen and lands on a tree and ends when the Raven flies away. But while sitting on the tree, Raven can perform a number of tasks. In the above example, the Raven says “Hello World” in Cree. But Raven can perform any number of activities, which occur randomly or are controlled through user interaction. It is in the tree-state that the actions of Raven can occur in any order, these activities are only dependant on the storyteller, as each storyteller that tells this story does so with slight modifications and changes in behaviours of Raven in order to emphasize a particular aspect of the story. The Cree# language favours this flexibility in the body of the story so that the generative and dynamic nature of the storyteller’s personality can be reflected in the code, the result is that though a similar (or same) story by different storytellers (i.e. programmers) will be noticeably different in their graphic output, even though they tell the same story.

For an example of what that looks like, here is a longer program in Cree#:

ᒥᔭᐦᑲᓯᑫ᙮
ᒪᒪᐁᐧᔭᐢ ᐃᐧᐦᐅᐃᐧᐣ ᐊᒐᑭᐯᐊᐧᓯᓇᐦᐃᑭᐧᐣ᙮ᑕᓂᓯ᙮
   ᐅᓯᐦᒋᑫᐤ ᑳᐦᑳᑭᐤ᙮
   ᐅᓯᐦᒋᑫᐤ ᒥᐢᑎᐠ᙮
▬
   ᑳᐦᑳᑭᐤ᙮ᐊᐧᐢᑭᑕᐢᑌᐤ᙮ᒥᐢᑎᐠ᙮
   ᐃ|| ᑲᐦᑲᑭᐘᐠ᙮ᐊᐧᐢᑭᑕᐢᑌᐤ᙮ᒥᐢᑎᐠ᙮
   | ᑳᐦᑳᑭᐤ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮
   ᑳᐦᑳᑭᐤ ᐃ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮
   ᑳᐦᑳᑭᐘᐠ᙮ᐅᔭᐱᐤ᙮
   ᑳᐦᑳᑭᐤ |᙮ᐃᑌᐧ᙮ᑕᓂᓯ ᒥᓯᐁᐧ ᐊᐢᑮᕀ᙮
   ᑳᐦᑳᑭᐤ᙮ᓇᓇᒫᐢᑲᒋᐤ᙮
   ᑳᐦᑳᑭᐤ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮
   ᒥᔭᐦᑲᓯᑫ ᒥᐢᑎᐠ᙮
◯

Because I am still working on the language there is no way to test the above code, so to provide a bit of background to Cree#: its intent is to capture story elements and animate them on the screen. Before writing the code, there must be a series of images or animations created first (like sprites or animated gifs). These are placed in applicable library folders that can then be used in the program by "Creating" them. The verbs used must also be predetermined and unique.
Now as far as the language itself goes the only punctuation in Cree is the full stop "᙮" which is used here to separate statements. The two glyphs used for "start" and "stop" are a horizontal bar "▬", and a circle "◯" respectively. Or in other words "open the circuit" and "close the circuit".

Commands follow basic sentence construction of [noun].[verb], and in some cases [noun].[verb][parameter], and in most cases as long as the program reads in those patterns the order of the instructions is not necessarily relevant. The only exception is smudge, which must be the first line of the program, can be the last line, and can also receive parameter(s) so [smudge] and [smudge][parameter].

Here is a quick run through of the example code:

In this example I start the program with a smudge, then declare two "noun" variables "Raven" and "Tree", open/start the "animation" on line 5. In the first two lines I first add one Raven (ᑳᐦᑳᑭᐤ) to the tree , the next line changes the singular Raven to an array of 5 Ravens (ᐃ|| ᑳᐦᑳᑭᐘᐠ) - note the suffix change from "ᐤ" to "ᐘᐠ", this changes the singular to the plural. And now when I reference the Raven its as an array I can use both singular and plural forms:
Line 8: 1 Raven leaves flying
     * because I don't indicate which Raven, one of the array is chosen at random and removed.
Line 9: Raven #3 leaves flying.
     * Note that placing a number at the end of the array variable indicates the index - see the end note about Cree numbers
Line 10: using the variable in its plural form ᑳᐦᑳᑭᐘᐠ means apply the action to the entire set
Line 11: Raven #1 speaks "Hello Turtle Island"
Line 12: Raven shivers with cold
Line 13: ᑳᐦᑳᑭᐤ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮    //Raven leaves flying
     * this actually only removes 1 raven at random, to remove all I could smudge the singular ᑳᐦᑳᑭᐤ or all ᑳᐦᑳᑭᐘᐠ, or send them all flying ᑳᐦᑳᑭᐘᐠ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮
Line 14: smudge the tree
     * the smudge function is used to "cleanse" or reset anything in the program. calling ᙮ᓯᐯᐧᐱᐦᐋᐤ᙮ without any variable will just wipe everything

A note on numbers - the glyphs used for Cree numbers are based on "sticks" with the vertical bar or pipe being 1, 2 pipes is 2, 3 pipes is the same as the syllabic ᐃ, 4 is then ᐃ| - an so on much like roman numerals. There are glyphs for indicating 5, 10, and 20, and higher numbers have differing ways of representing them. An extended example - in many Indigenous numbering systems (not just Cree) the representation of 5 is a hand, and 20 is a person or body, because we are made of 20 digits (10 fingers and toes).

Cree is also a morphemic language, so as long as you know the rules for combining syllables your programming can also be a series of syllable commands strung together. For example there is a prefix "mista" (ᒥᐢᑕ) that can be added to a word to make it a larger version of itself, like ᒥᐢᑕᑳᐦᑳᑭᐤ would be Big Raven, in Cree# this is also a way of adding so - ᒥᐢᑕᑳᐦᑳᑭᐤ (literally big ravens) would actually be a way of increasing my array of 5 Ravens to 6 Ravens. Likewise the suffix "osis" (ᐅᓯᐢ) makes it smaller. ᑳᐦᑳᑭᐤᐅᓯᐢ would therefore remove 1 from the array. And though I have yet to see a need for it, combining the two is still a legal statement so “mista-kahkakiw-osis” or ᒥᐢᑕᑳᐦᑳᑭᐤᐅᓯᐢ, is the same as saying Raven = Raven + 1 - 1.

The last 10 years as seen many people question traditional monetary models. One of the results of this has been the rise, fall, and rise (and perhaps fall or statis), of various cryptocurrencies like bitcoin and ethereum. Cryptokitties is an example of a smart contract. It is a particular kind of smart contract, a token. And it is a particular kind of token, a non-fungible token. So if a regular token is like a $1 bill (all $1 bills are the same), a non-fungible token is like a jewel or collectable. Each jewel is slightly different from another one.

CryptoKitties are representations of virtual kitties that are non-fungible tokens. Cryptokitties would be 'born' at random intervals with different attributes, and then could breed with one another to create new cryptokitties. Cryptokitties became enormously popular with some being exchanged for 100,000s USD. It spawned the creation of a new Smart Contract Standard - ERC-721, and people working in this field. There are a number of Solidity smart contracts that allow cryptokitties to work. You can see them all on github. This code snippet is the base class of the CryptoKitty itself.

Some wide ranging questions about the code:
1. What makes this code? If we take a legal contract and translates it into a smart contract. What does it gain or lose in becoming code (or a smart contract)? What happens when it become a subject of software studies in addition to legal studies? How is this different from say the a header file and the implementation, or a configuration file? Do they both have the same status as code?

2. The code includes very specific ideas about embodiment, biology, and genetics. What is the impact of that on the community of coders and collectors and the kitties themselves. For example, what would it look like if we had Cryptokitties based on Haraway's notion of Kin (or even cyborgs).

3. This sort of program 'performs' in a different way than other programs in that it has (or generates) exchange value in the world. Is this relevant at all to our discussion software? If we consider software to be 'performative' or a 'Speech Act' in a JL Austin way, are there different categories of acts for software? Is this a function of the software or of the compiler or platform?

4. Can we consider this program apart from the Ethereum platform? What is the relationship between this software and the network it runs on, can we consider it in isolation? Is this a similar question to ML and the training set of Data.

5. What cultural ideas are embedded here: a love of cats memes on the internet, KittyAccessControl, Matron, Sire, auctioning kitties in general, cooldown period (is this like a nuclear reactor)?

6. Money - but we have enough to talk about.

/// @title Base contract for CryptoKitties. Holds all common structs, events and base variables.
/// @author Axiom Zen (https://www.axiomzen.co)
/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged.

contract KittyBase is KittyAccessControl {
    /*** EVENTS ***/

    /// @dev The Birth event is fired whenever a new kitten comes into existence. This obviously
    ///  includes any time a cat is created through the giveBirth method, but it is also called
    ///  when a new gen0 cat is created.
    event Birth(address owner, uint256 kittyId, uint256 matronId, uint256 sireId, uint256 genes);

    /// @dev Transfer event as defined in current draft of ERC721. Emitted every time a kitten
    ///  ownership is assigned, including births.
    event Transfer(address from, address to, uint256 tokenId);

    /*** DATA TYPES ***/

    /// @dev The main Kitty struct. Every cat in CryptoKitties is represented by a copy
    ///  of this structure, so great care was taken to ensure that it fits neatly into
    ///  exactly two 256-bit words. Note that the order of the members in this structure
    ///  is important because of the byte-packing rules used by Ethereum.
    ///  Ref: http://solidity.readthedocs.io/en/develop/miscellaneous.html
    struct Kitty {
        // The Kitty's genetic code is packed into these 256-bits, the format is
        // sooper-sekret! A cat's genes never change.
        uint256 genes;

        // The timestamp from the block when this cat came into existence.
        uint64 birthTime;

        // The minimum timestamp after which this cat can engage in breeding
        // activities again. This same timestamp is used for the pregnancy
        // timer (for matrons) as well as the siring cooldown.
        uint64 cooldownEndBlock;

        // The ID of the parents of this kitty, set to 0 for gen0 cats.
        // Note that using 32-bit unsigned integers limits us to a "mere"
        // 4 billion cats. This number might seem small until you realize
        // that Ethereum currently has a limit of about 500 million
        // transactions per year! So, this definitely won't be a problem
        // for several years (even as Ethereum learns to scale).
        uint32 matronId;
        uint32 sireId;

        // Set to the ID of the sire cat for matrons that are pregnant,
        // zero otherwise. A non-zero value here is how we know a cat
        // is pregnant. Used to retrieve the genetic material for the new
        // kitten when the birth transpires.
        uint32 siringWithId;

        // Set to the index in the cooldown array (see below) that represents
        // the current cooldown duration for this Kitty. This starts at zero
        // for gen0 cats, and is initialized to floor(generation/2) for others.
        // Incremented by one for each successful breeding action, regardless
        // of whether this cat is acting as matron or sire.
        uint16 cooldownIndex;

        // The "generation number" of this cat. Cats minted by the CK contract
        // for sale are called "gen0" and have a generation number of 0. The
        // generation number of all other cats is the larger of the two generation
        // numbers of their parents, plus one.
        // (i.e. max(matron.generation, sire.generation) + 1)
        uint16 generation;
    }

    /*** CONSTANTS ***/

    /// @dev A lookup table indicating the cooldown duration after any successful
    ///  breeding action, called "pregnancy time" for matrons and "siring cooldown"
    ///  for sires. Designed such that the cooldown roughly doubles each time a cat
    ///  is bred, encouraging owners not to just keep breeding the same cat over
    ///  and over again. Caps out at one week (a cat can breed an unbounded number
    ///  of times, and the maximum cooldown is always seven days).
    uint32[14] public cooldowns = [
        uint32(1 minutes),
        uint32(2 minutes),
        uint32(5 minutes),
        uint32(10 minutes),
        uint32(30 minutes),
        uint32(1 hours),
        uint32(2 hours),
        uint32(4 hours),
        uint32(8 hours),
        uint32(16 hours),
        uint32(1 days),
        uint32(2 days),
        uint32(4 days),
        uint32(7 days)
    ];

    // An approximation of currently how many seconds are in between blocks.
    uint256 public secondsPerBlock = 15;

    /*** STORAGE ***/

    /// @dev An array containing the Kitty struct for all Kitties in existence. The ID
    ///  of each cat is actually an index into this array. Note that ID 0 is a negacat,
    ///  the unKitty, the mythical beast that is the parent of all gen0 cats. A bizarre
    ///  creature that is both matron and sire... to itself! Has an invalid genetic code.
    ///  In other words, cat ID 0 is invalid... ;-)
    Kitty[] kitties;

    /// @dev A mapping from cat IDs to the address that owns them. All cats have
    ///  some valid owner address, even gen0 cats are created with a non-zero owner.
    mapping (uint256 => address) public kittyIndexToOwner;

    // @dev A mapping from owner address to count of tokens that address owns.
    //  Used internally inside balanceOf() to resolve ownership count.
    mapping (address => uint256) ownershipTokenCount;

    /// @dev A mapping from KittyIDs to an address that has been approved to call
    ///  transferFrom(). Each Kitty can only have one approved address for transfer
    ///  at any time. A zero value means no approval is outstanding.
    mapping (uint256 => address) public kittyIndexToApproved;

    /// @dev A mapping from KittyIDs to an address that has been approved to use
    ///  this Kitty for siring via breedWith(). Each Kitty can only have one approved
    ///  address for siring at any time. A zero value means no approval is outstanding.
    mapping (uint256 => address) public sireAllowedToAddress;

    /// @dev The address of the ClockAuction contract that handles sales of Kitties. This
    ///  same contract handles both peer-to-peer sales as well as the gen0 sales which are
    ///  initiated every 15 minutes.
    SaleClockAuction public saleAuction;

    /// @dev The address of a custom ClockAuction subclassed contract that handles siring
    ///  auctions. Needs to be separate from saleAuction because the actions taken on success
    ///  after a sales and siring auction are quite different.
    SiringClockAuction public siringAuction;

    /// @dev Assigns ownership of a specific Kitty to an address.
    function _transfer(address _from, address _to, uint256 _tokenId) internal {
        // Since the number of kittens is capped to 2^32 we can't overflow this
        ownershipTokenCount[_to]++;
        // transfer ownership
        kittyIndexToOwner[_tokenId] = _to;
        // When creating new kittens _from is 0x0, but we can't account that address.
        if (_from != address(0)) {
            ownershipTokenCount[_from]--;
            // once the kitten is transferred also clear sire allowances
            delete sireAllowedToAddress[_tokenId];
            // clear any previously approved ownership exchange
            delete kittyIndexToApproved[_tokenId];
        }
        // Emit the transfer event.
        Transfer(_from, _to, _tokenId);
    }

    /// @dev An internal method that creates a new kitty and stores it. This
    ///  method doesn't do any checking and should only be called when the
    ///  input data is known to be valid. Will generate both a Birth event
    ///  and a Transfer event.
    /// @param _matronId The kitty ID of the matron of this cat (zero for gen0)
    /// @param _sireId The kitty ID of the sire of this cat (zero for gen0)
    /// @param _generation The generation number of this cat, must be computed by caller.
    /// @param _genes The kitty's genetic code.
    /// @param _owner The inital owner of this cat, must be non-zero (except for the unKitty, ID 0)
    function _createKitty(
        uint256 _matronId,
        uint256 _sireId,
        uint256 _generation,
        uint256 _genes,
        address _owner
    )
        internal
        returns (uint)
    {
        // These requires are not strictly necessary, our calling code should make
        // sure that these conditions are never broken. However! _createKitty() is already
        // an expensive call (for storage), and it doesn't hurt to be especially careful
        // to ensure our data structures are always valid.
        require(_matronId == uint256(uint32(_matronId)));
        require(_sireId == uint256(uint32(_sireId)));
        require(_generation == uint256(uint16(_generation)));

        // New kitty starts with the same cooldown as parent gen/2
        uint16 cooldownIndex = uint16(_generation / 2);
        if (cooldownIndex > 13) {
            cooldownIndex = 13;
        }

        Kitty memory _kitty = Kitty({
            genes: _genes,
            birthTime: uint64(now),
            cooldownEndBlock: 0,
            matronId: uint32(_matronId),
            sireId: uint32(_sireId),
            siringWithId: 0,
            cooldownIndex: cooldownIndex,
            generation: uint16(_generation)
        });
        uint256 newKittenId = kitties.push(_kitty) - 1;

        // It's probably never going to happen, 4 billion cats is A LOT, but
        // let's just be 100% sure we never let this happen.
        require(newKittenId == uint256(uint32(newKittenId)));

        // emit the birth event
        Birth(
            _owner,
            newKittenId,
            uint256(_kitty.matronId),
            uint256(_kitty.sireId),
            _kitty.genes
        );

        // This will assign ownership, and also emit the Transfer event as
        // per ERC721 draft
        _transfer(0, _owner, newKittenId);

        return newKittenId;
    }

    // Any C-level can fix how many seconds per blocks are currently observed.
    function setSecondsPerBlock(uint256 secs) external onlyCLevel {
        require(secs < cooldowns[0]);
        secondsPerBlock = secs;
    }
}

Code Critique - CryptoKitties

Hi all, I wanted to start a thread to invite you to consider the role of code in contemporary gallery/ museum spaces as it is being used to further AI innovations.

Background info––

I am currently a PhD student and I study code and algorithms as they intersect with experimental writing, and creative technologies that center notions of ancestral knowledge, movement, and self-becoming within black diasporas. My dissertation project examines 5 artistic projects that convey a genealogy of creative and critical approaches to data (both analog and digital) through a politics of gender and race. The analysis ends on a case study of a current art project using data and algorithmic driven technology, specifically Recursive Neural Networks (RNN) to make an AI sculpture engendered through data on three generations of black women experiences. In short, I encounter code the most in galleries, museums, artists’ studios, and creative community based workshops. The code critique I am posting is concerning an art exhibition I went to at the Barbican Center in London called "AI More than Human". While initially I contemplated my experience from a Critical Data Studies perspective, I am most certainly interested in how a Critical Code Studies perspective can advance this line of thought!

Code Critique / Inquiry––

In the exhibition AI: More than Human (2019) interactive digital art captivated the audience. Imagine, a large dimly lit crescent shaped room. Inside, a mild discordant hum of computer processing units (CPUs), flashing touch screens with various visual materials, these are some of the elements that characterized the breadth of artwork on display. An array of works by corporations and artist were presented including Affectiva, the leader in Human Perception AI, Mario Klingemann’s "Circuit Training", and Sony CSL’s "Kreyon City". For these select works ( however not limited to) the exhibition was a site to further train the neural networks of AI and large databases with participants as data. I went to this exhibition to examine the speech patterns of “Not The Only One” by Stephanie Dinkins (after its latest training session) but was struck by the exhibition as a whole. I read the moments of audience participation and their data contributions (some known and unknown) as a transformation of the Barbican gallery space into a kind of information research lab, and I am curious about this approach to data collection for AI, and use of code.

This line of inquiry is part of a larger ongoing thought process, but I would love to incite a generative discussion considering: the role of code and data in the 21st century gallery/ museum space (especially the collaboration/juxtaposition of corporate and independent artist use)? How is code being enacted in this nuanced mode of artistic driven data collection? Would programming in Indigenous languages change the ethical terms of this data collection (especially for underserved communities) ?

Feel free to add and/or further along the questions!

One consideration of ethical coding is authorial intentionality of the code. Was the code written to add or remove functionality? Did the change correct logical or assumption flaws that caused unintentional outcomes – bug fixes? Was it modified to safeguard against potential security threats? Was something changed to purposely usurp control, creating a backdoor, of unwitting consumers of such code?

As Kevin Brock highlights in Rhetorical Code Studies, the code fix for Heartbleed, a security vulnerability in the OpenSSL software, was simple yet overlooked through multiple code contributions to the open source project. The fix added a few lines of code to perform two checks about the amount of data stored and expected to prevent bad actors from reading potential data not intended for them. Brock adds how activities around the security flaw “can and do…exert tremendous influence over how individuals and communities respond to and deal with the consequences of writing code” (10).

Borrowing from Stuart Power’s simple one-line PHP backdoor example from GitHub, re-shown here:

    <!-- Simple PHP Backdoor By DK (One-Liner Version) -->
    <!-- Usage: http://target.com/simple-backdoor.php?cmd=cat+/etc/passwd -->
    <?php if(isset($_REQUEST['cmd'])){ echo "<pre>"; $cmd = ($_REQUEST['cmd']); system($cmd); echo "</pre>"; die; }?>

We might be quick to assess the applied ethical intention of the code to be immoral or evil to some degree. While using it requires certain security measures of a server to be permissive, and it assumes a UNIX operating system based on usage example, the code provides a rudimentary method to run system commands by visiting the URL where this code might run.

Other lengthier examples of overt instances of what might be considered unethical code exists; however, examining the less obvious coding approaches, such as code and code bases in common use, as Brock highlights with OpenSSL, might lead to better design and development practices for projects with “good” intentions.

Some questions that come to mind in code examination as well as in the practice of code design and development are:

• At what stages of design and development do we confront ethical decisions and to what scale?
• In Ethical Programs: Hospitality and the Rhetorics of Software, James Brown states, regarding ethical predicaments and decision-making in code, “these steps are not necessarily arrived at rationally, and they are not always the result of deliberation” (5). How might we examine code or code base, reflectively, to identify pivotal moments of ethical predicaments?
• What might be some guiding principles towards more ethical coding practices?
• Thinking of the one-line code example, at what threshold does code transform into algorithm or agent/actor with ethical intentionality? Does it take only one line of code?
• Regarding environmental ethics, can code be ethical or unethical based on its level of resource and power consumption? Can we write code to be more environmentally friendly?

Works Cited

Brock, Kevin. Rhetorical Code Studies: Discovering Arguments in and around Code. University of Michigan Press, 2019.
Brown, James J. Ethical Programs: Hospitality and the Rhetorics of Software. University of Michigan Press, 2015.

by Jon Corbett, Outi Laiti, Jason Edward Lewis, Daniel Temkin

Our group will discuss Indigenous Programming; that is, code and programming languages built on spoken and written Indigenous languages.

With the wider support for Unicode, there has been an uptick in languages that challenge English's dominance. The most widely remarked-upon in the academic community is قلب by Ramsey Nasser, an Arabic LISP (also discussed in the 2014 working group). It showed not just that such a language is possible, but through the difficulties in making it functional, illustrated the Western biases of tools used by programmers. Another example is Yorlang, a Yoruba-based programming language by Karounwi Anu, a Nigerian developer. He uses English with his clients, but Yoruba with his friends, and wanted to be able to write code in the language they consider their own.

Outi Laiti's thesis on Ethnoprogramming gives insight into these works. She shows how programming's hardware and software levels rest on a terminology level, which itself rests on a cultural level. People who are excluded from the cultural level may find the other levels more challenging and be discouraged from programming. Alternately, they may be forced to embrace an English-based programming language, thus reinforcing a colonial language’s dominance locally. As Laiti says, "If we want to see a new generation of computer programmers who blur the borders of language, gender and culture, the ethnic side of computing needs to be researched and discussed."

However, what sets apart indigenous languages specifically can be difficult to define. Even the term Indigenous itself is debated. In her thesis, Laiti remarks on how the term has been criticized in defining people by their connection to colonial history. However, she provides an outline that might be helpful: "Indigenous people have their own language. They have a small population inside a dominant culture of the country. They still practice their cultural traditions and at last, some of them live in a territory that is, or used to be, theirs. They identify themselves as Indigenous people." Part of the issue arises from Western concepts of Indigeneity as analogous, that regardless of geographic locale being Indigenous merely means non-European/Western. But to say, for example, that Indigenous people in Papua New Guinea share the same or similar political and cultural concerns of the Inuit people would be false. However, there is a commonality that could be seen as a Pan-Indigenous lens and that is the socio-political and cultural perspectives of Indigenous people collectively contest the power of assimilationist nation-states and strongly self-advocate for community sovereignty and autonomy.

Beyond the question of bringing these languages into the text of code are how Indigenous culture might shape programming language design at a deeper level. Jon Corbett’s Cree# language, which we will look at more deeply in a code critique thread, serves as an example. In Cree#, each program begins with smudging, a command that mirrors the ceremonial cleansing practice common to many North American Native people. This practice in life is intended to clear the mind, ears, eyes, mouth, heart, body and spirit. In his digital incorporation of this ceremony, the smudge command clears the buffer, resets the virtual machine to an initial state, and prepares it for a new activity. This connects the computer’s activities to living practices and by extension becomes braided and harmonious with everyday life.

We invite you to join us in exploring these and other issues in Indigenous computation, with these questions in mind:

• With the advancements in language technologies (unicode, etc), why is 90% of all computing done in English still? Is this changing? Why can’t we write code in our ancestral languages?

• What is uniquely at stake for Indigenous communities vs. other communities that happen to speak languages other than English?

• How do we get code to reflect Indigenous thinking beyond just using relevant keywords? How can we bring the cultural logic of the community into the language?

Before we begin code critiques, we have to find the bodies of code worth investigating. Over the past ten years, we’ve looked at a wide range of code. For example,

• The Apollo moon lander
• ADVENTURE
• FLOW-MATIC, a forerunner to COBOL
• The Transborder Immigrant Tool

It turns out one of the most productive intellectual contributions you can make to critical code studies is to identify a body of code worth considering. That activity, of identifying an object worth analyzing, launches the investigation and incites exploration.

Why is this activity so important? Primarily because to call out a body of code as worthy of exploration is to say this artifact has significance. While CCS contends that all code has significance beyond what it does, for a scholar to turn a spotlight on a piece of code is like choosing a book for a book club or perhaps more significantly to present a work on on display in a museum. In the same way the Code Critiques do, that act of curation gives the rest of us a chance to walk around and consider various aspects -- and we can help find snippets worth exploring further.

Let us begin this thread with a call for codebases -- a call for you to identify programs or entire pieces of software worth exploring. These could be in repositories or merely a single file -- as long as the code is publically available for collective exploration.

So we put out the call to you? What codebases do you want to identify?

Welcome to the first week of the 2020 Critical Code Studies Working Group. During this week, we’ll be introducing critical code studies in general by means of the introductory chapter to the forthcoming book Critical Code Studies (The MIT Press). We’ll also take this week as an opportunity to introduce newcomers to the field but also to take stock in where the field has come and to look forward to where it is headed next.

Critical code studies names the applications of hermeneutics to the interpretation of the extrafunctional significance of computer computer source code…. Extra here means not outside of or in addition to but instead growing out of…. CCS holds that the lines of code of a program are not value-neutral and can be analyzed using the theoretical approaches applied to other semiotic systems, in addition to particular interpretive methods developed specifically for the discussions of programs.

But what does it mean to explore culture through code?

Mark answers this question in the book, reading code as varied as the leaked software from the Climategate scandal to code written by media philosopher Friedrich Kittler. He reads art objects like the Transborder Immigrant Tool, variants of electronic literature works like Taroko Gorge, and code languages like the English-like precursor to COBOL, FLOW-MATIC. He explores low level to high level languages, from ASSEMBLY to Inform 7, including languages in Arabic (قلب or ’alb), Hawiian (in the ʻAnuʻu project), and Cree. (For much more on Indigenous Programming, look forward to our Week 2 discussion). In a medium most consider to be merely an operationalized mathematics, readings of code lead him to discuss issues of racial and ethnic bias and the gendered bias he calls encoded chauvinism. These readings have grown out of and reference discussions from past Critical Code Studies Working Groups because these collectives, these gathering of such varied minds, have the ability to identify so many complex meanings.

In the epilogue to the CCS book, Mark claims we have reached a moment where “philosophers process, poets publish, and curators collect code knowing scholars will interpret it as discourse” (227) -- in other words, where the basic tenets of critical code studies, that code is meaningful, have been widely accepted. How does that acceptance change the culture of code? How does that facilitate what we are trying to do here?

Because code has become accepted as a means of expression, we now have new works choosing code as one of their communication channels. Consider: Eugenio Tisselli's “Amazon” webpage, released over Twitter. Created in response to this summer’s devastating fires, Tisselli’s code articulated his despair over the environmental effects of globalized capitalism. Code was able to serve as his language of expression because, as, Alex McCLean and Geoff Cox have written, Code Speaks.

see related discussion: amazon.html by Euguenio Tisselli

Code is a social medium and its meaning is also social. The “critical” aspect of critical code studies looks to explore, among other aspects, this social dimension, especially as it pertains to power relations, across differences of race, gender, sexuality, and socio-economic status or class. “Critical” code studies is not technological history at the service of digital industries, it is an exploration of human culture in code complete with biases, abuses, inconsistencies, and injustices. CCS is an alternative to “uncritically documenting military-industrial-academic artifacts on behalf of those who created them to the benefit of their creators’ self-regard” (238). We aspire to more.

At the same time, it is worthwhile to look to critical theories and philosophical paradigms that you have found useful or would like to apply but perhaps can’t see how. Or maybe you have come across some code that you can’t read or can’t find a critical hand hold on. (This is a good time to introduce some of your code critique threads).

Programming has continued to evolve. New and strange languages have emerged. With the advent of contemporary machine learning algorithms, more code is being generated by software, code that programmers may never deal with directly. How does meaning change in such contexts? As more people discuss algorithms, what can the study of code add to those conversations?

So we invite the CCS community to begin this week of the Working Group with a broad, reflexive conversation, a thread that invites you to look back and forward, that invites you to express your thoughts about the potential obstacles for critical code studies as well as your own insights and inspirations.

Some questions:

• What do you want to know about CCS?
• What are the next challenges for Critical Code Studies? Current puzzles?
• What projects would we like to launch in the coming years? An edited collection? Conference?
• How has CCS been most productive?
• What are some current questions or problems that CCS is uniquely suited to addressing?
• What are the lacuna or blindspots--what should should CCS be addressing that it is not currently?

Language - Extensible 3D (X3D) - (Technical support https://www.web3d.org/)

X3D - Features - https://www.web3d.org/sites/default/files/page/X3D Version 4 Overview/FutureOfX3D.pdf

X3D version 4 - Draft - https://www.web3d.org/specifications/X3Dv4Draft/ISO-IEC19775-1v4-WD1/

Software and hardware requirements - For programming on-line we can use the HTML Editor of a blog related to the Google (Blogger.com) platform and the (X3Dom framework features (https://www.x3dom.org/). Any browser and computer devices able to run webgl graphical libraries related to the X3Dom framework.

Alternatively, for the places without online resources and connectivity, use standalone open source browsers such as (Freewrl working on personal computers and mobile android systems (http://freewrl.sourceforge.net/)) and or the instant reality framework (https://www.instantreality.org/) for personal computers. There is also Titania X3D editor for Linux users (http://create3000.de/titania/whats-new/ - http://create3000.de/users-guide/)

The K-12 educational context of using X3D language for inspiring students and educators' coding literacy is that such language and tools have gained sustainable accessibility. This accessibility has addressed problems of how to use advanced digital computing resources for deepening technical and scientific knowledge in an integrated way. An example of this possibility is analyzed through the following code created in 2019 for supporting an before/after-school project and experimental computing education processes 8th grade individuals' learning and applying scientific concepts. (For testing it, the code bellow can be visualized in a blog HTML editor or at codepen org text editor (https://codepen.io/education/).

Code:

Our First 3D Virtual Reality Museum

3D Virtual Reality in November at Ernani Primary School!

Our first complex 3D digital content production work.

Nosso primeiro trabalho de conteúdo digital complexo.

      <x3d width='1400px' height='900px'> 
        <scene> 

          <transform translation='0 0 0'> 
              <shape> 
                    <appearance> 
                             <material diffuseColor='1 0 0'></material> 
                  </appearance> 
                          <box size= '60.0, 0.1, 90.0' solid='false'></box> 
               </shape> 
           </transform> 

          <transform translation='-25 5 0'> 
              <shape> 
                    <appearance> 
                             <material diffuseColor='0 0 1'   transparency='0.5'    ></material> 
                  </appearance> 
                          <box size= '0.5, 10.0, 90.0' solid='false'></box> 
               </shape> 
           </transform>    

          <transform translation='-24.8 5 -30'> 
              <shape> 
                    <appearance> 
                      <ImageTexture  url="https://scontent.fcgh11-1.fna.fbcdn.net/v/t1.0-9/73495085_10157162660278393_5012001546217455616_n.jpg?_nc_cat=109&_nc_oc=AQnzj8J-BiwWBDQp9hyX7Z855Y2aLB4jXl4ZylXsQhWV0n3BfuMtCAYQp_qdXO3l6ns&_nc_ht=scontent.fcgh11-1.fna&oh=387c183fc4e0b252e1e8151a066ff9c4&oe=5E5966E8"><ImageTexture/>
                             <material diffuseColor='0 1 0'   transparency='0.2'    ></material> 
                  </appearance> 
                          <box size= '0.2, 7.0, 14.0' solid='false'></box> 
               </shape> 
           </transform>    

          <transform translation='-24.8 5 30'> 
              <shape> 
                    <appearance> 
                     <ImageTexture  url="https://scontent.fcgh11-1.fna.fbcdn.net/v/t1.0-9/74290224_10157188420193393_5945857161560064000_n.jpg?_nc_cat=106&_nc_oc=AQl_jFIYgphh3gK4soJOln3Jvz-k3Uddk7ZlgETCB-1MKOMbifW7Ba3yJGhvCprQJSY&_nc_ht=scontent.fcgh11-1.fna&oh=dd8fb33e87a60dc03940ce35254da2e2&oe=5E4CF0E6"><ImageTexture/>
                             <material diffuseColor='0 1 0'   transparency='0.2'    ></material> 
                  </appearance> 
                          <box size= '0.2, 9.0, 12.0' solid='false'></box> 
               </shape> 
           </transform>    

        </scene> 
     </x3d> 

Visualization Image in Codepen editor:

The accessibility and modularity of the X3D language through the X3Dom framework has allowed to use it for supporting before/after-school computing education projects. However, attempting to integrate the projects dynamics with learning and teaching scientific concepts from the k-12 curriculum as explained in the quote bellow.
"This code literacy case highlights a connection between real and virtual worlds, extending the source code analyses of figure 1 (b), in section 2.1, with HCI at ESB’s school lab and beyond. For example, there is a meaning of using a (real) ruler and comparing its functionalities with the ones of the (virtual and non-visible / immaterial software behind the scene of the digital box described) in the command line ( ) in the figure 1 (b) (text in blue picture below). This objects comparison helped author 1 and a student from 8th grade communicative processes. By comparing the Cartesian coordinate system X, Y and Z with the ruler measuring functionalities they got insights related to decimal numbers (0.4) and size proportions, encompassing ((length (X), height (Y) and depth (z)) through real time sensorial and multidimensional stimuli based on applying VR and its features like physical and mental immersion, sensory feedback and interactivity. The described objects’ connection inspired visual and tactile interactions via reading a programming code template on a sheet of paper and digitizing (reading through writing) code source via a keyboard, in the figure 2 (b), and visualizing the symbolic representation of the code programmed in the form of a 3D rectangular geometric object placed in the 3D interactive interface produced utilizing principles of digital storytelling in a blog created by the student [49]. It includes, navigating the blog 3D scenery with a mouse for interacting with this particular piece of 3DVR rectangle object created using the blog HTML text editor for coding X3D language algorithms linked with computer graphics libraries related to the X3Dom framework. These design, creative, participatory, communicative and 3D navigation starting point processes stimulated the production of new 3D objects. Such production processes implicated in stimulating ones’ spatial reasoning materialized through transforming and translating the initial 3D rectangle shape and position throughout reusing the initial source code. For that, the student reused two command lines successively (first for reshaping the rectangle and second for moving it to diverse positions) until the adapted rectangle pieces together form a box with four lateral walls as showed in the figure 2 (d) on the computer screen (educator programming using Code pen editor - picture bellow)." (Franco; Oliveira, 2019)

text in blue picture below

educator programming using Code pen editor - picture bellow

This type of computing education at k-12 levels has addressed how to inspire inclusive and equality education in terms of gender and ethnicity knowledge enhancements and participation in computing. It includes inspiring ones' tacit knowledge application in lifelong learning attitudes (FRANCO et al., 2007(https://www.researchgate.net/publication/260386601_DEVELOPING_INTERACTIVE_EDUCATIONAL_ENVIRONMENTS_TO_STIMULATE_LIFELONG_LEARNING) ;FRANCO; LOPES, 2012 -https://www.intechopen.com/books/computer-graphics/developing-an-interactive-knowledge-based-learning-framework- ) beyond a reductionist technical perspective of reading and writing computer code (BROCK, 2019, https://www.researchgate.net/project/Rhetorical-Code-Studies).

Individuals improving reading and writing skills through acquiring and developing coding and visual literacy abilities.

Enhancing Educators' digital skills in service preparation

Gender and ethnicity inclusion and equality in computing education using a connection between real and virtual resources through acquiring and applying digital and scientific knowledge at the natural environment of school computers lab since k-12 levels.

Example 1 - 8th grade students and educator during computational practices at school computer lab

Example 2 - reading, writing, communicating through acquiring coding literacy using a connection between real and virtual materials

Blogs construction are some results of a 8 week interactive and collaborative knowledge based computing education processes with 8th grade students at the end of 2019.

https://vitorick.blogspot.com/2019/11/3d.html
https://lauraevellynmariafernanda.blogspot.com/

Educators blogs
https://experiencyas.blogspot.com/2019/09/blog-post_28.html
http://englishartworkaternaniprimaryschool.blogspot.com/

*Function called every frame on this Actor. Override this function to implement custom logic to be executed every frame. *Note that Tick is disabled by default, and you will need to check PrimaryActorTick.bCanEverTick is set to true to enable it. * *@param DeltaSeconds Game time elapsed during last frame modified by the time dilation

virtual void Tick( float DeltaSeconds );

Overview
Tick is the method used on Unreal Engine to allow programmers to execute code before each frame of the game is rendered.
This code is executed several times per second, and it's critical for the overall performance of the game. In a conservative scenario, a video game rendering at 30 frames per second will call this function at least one time for each actor.

Questions for Discussion
Some of my questions are derived from my lack of experience in academic research, so please bear with me

• The sample code is the virtual declaration of the method. There are several implementations of it in the Unreal Engine source code and a lot more for each custom implementation. Should I work with the virtual declaration or use some of the definitions?
• One of the subjects that interest me is the power hierarchy that Game Engines have. Maybe it would be interesting to dig into the power relationships that this kind of structure can create between the engine's creators and the developers using that technology. I would love to hear your opinions on this.
• The other subject is related to the human perception and this kind of code that executes at great speed and makes a lot of operations to generate the images we see in a video game. The thing with this option is that I don't know where to start
• I also would love to hear any other ideas

There is a rich history of queer subcultures sending coded messaging to each other. A message that only an insider would parse. Historically, in the Western world people assigned female at birth have used various codes to signal their queerness: neckwear, hairstyle, keychains, rings, and more. People assigned male at birth (and particularly within working classes) developed a sophisticated “hanky code” for communicating varying levels of interest in specific forms of engagement. Someone outside queer subculture wouldn’t think much of seeing a light blue bandana on someone’s back pocket, on the right side. To a person who can read that message, that communicates that the wearer is interested in providing oral sex. Historically, this has been an act of hiding in plain sight, and a way for people to find each other and connect efficiently, with or without words. It’s a very customized usage of presentation to communicate preferences outside dominant social norms.

Since front end coding performs acts of presentation, I’m interested in what can adaptive, fluid coding contribute to how bodies in real life transgress dominant social norms. In my view, possibilities can become examples, and examples can become referent points for progress.

Looking for an answer to this question led me to one project addressing gender fluidity, but this project was specifically about mapping human experience, and visualizing data points/feelings: Plot me Genderfluid. There’s so much value in this project, from so many points of inquiry, I enjoyed it so much! Yet, Plot me Genderfluid remains within the limitations of ‘code as we know it’ not code being questioned, or summoned to challenge our own imagination in real life. Not because coding is by itself some kind of oracle, but because it can bring about new points of/for inquiry. Plot me Genderfluid exposes, it does not instigate.

Increasingly we talk about how less dominant forms of gaming and mobile games can be a catalyst for empathy. An example of this is the mobile game Bury Me, My Love in which the Syrian refugee crisis is the setting for experiences designed for the player to feel empathy. But we don't consider code that way, do we? We don't discuss code as having the potential of generating empathy through its syntax, composition, and delivery (of an experience, rather than data).

My questions to the group are:

1) How can we shape fluid modes of coding so that such forms can instigate forms of transgression? Specifically, through experiences, not just the presentation of data.

2) How can fluid syntaxes invite us to imagine ways of being more at ease in the real world, as queer people? As a member of marginalized communities?

3) What we can do to respatialize micro*** digital infrastructures to prioritize equity in real life?

How each of these possibilities are made, navigated, and re-ordered is of high interest to me.

Notes:
** I’m specifically discussing the only fluid forms of coding I have experience with (HTML, CSS, Javascript), but I’m open to knowing about other forms of fluid coding that are front-end based and structured to be adaptive.

*** I use 'micro' to mean individually crafted, independent projects, rather than a 'macro' apparatus, an existing corporate entity, or projects derived from existing corporate legacy products. Example: micro=github; macro=Oracle

For further reading:
Untucking the Queer History of the Colorful Hanky Code, Out.com, June 2019.

I am going to start things off by introducing our topic. Shawné will respond. Then I'll post some code examples. Following that, we hope to engage in an open-ended dialog, which we invite CCSWG participants to join.

FloodNet was developed in 1998 by the Electronic Disturbance Theater (EDT), a group of artists and activists working in the area of Electronic Civil Disobedience (ECD). FloodNet enabled activists to hold "virtual sit-ins." Using HTML pages and some minimalist Java code, participants could stage an online protest by flooding a targeted server with repeated requests for pages. Typically, a time would be set for the protest, participants would open the FloodNet home page during the protest and an applet embedded in the page would send out requests from the client page to the targeted server every 7 seconds. Participants could also send "personal messages" encoded as URLs to the server. The client would request a non-existent page, causing the server to generate and log a "404 Page Not Found" error, for example: "welcome//impartiality/_and_respect not found" or "welcome//human_rights/_and_dignity not found". If enough people participated, they would have a noticeable impact on the server response time, potentially flooding it with so many requests that it would crash. In other words, FloodNet operated as a DDoS (Distributed Denial of Service) attack.

DDoS as protest was controversial from the start. As Geert Lovink notes, "...hackers were divided over the effectiveness of the Floodnet software[...]. Libertarian minded hackers suggested that the 'flooding' of corporate and government servers was ending up nowhere. Massive hit attacks, directed at the enemy site were getting lost in the general net, thereby mostly harming others, in particular your local ISP." Governments also took notice and began taking steps to make such attacks illegal, conflating political DDoS with terrorist attacks on the Internet. [Lovink 2002, pp. 254-274]

The most well-known use of FloodNet was in a series of protests in support of the Zapatista social movement (or "insurgency" as sources in the Mexican government would have it) in the state of Chiapas, Mexico. Without going into the depth that the topic deserves, I would note that the Zapatista Movement, which continues to the present day, offered models of decentralized organization both in its political philosophy (i.e., having as its public face "Sub-Comandante" Marcos, who functioned more as a spokesperson than a leader meting out decisions) and in its cultural roots as an indigenous movement protesting among other injustices the latifundio system of land ownership brought by the Spanish colonists, which saw shared ownership and cultivation reduced to single ownership over vaste expanses and cultivation ordered "a dedo," by pointing to whomever would be given work in a pool of marginally employed day-laborers. The Zapatista Movement was very savvy in its use of media, and in many respects centered its strategies around defensive or non-violent protest actions, community organization, and occupation of lands. The style and open organization of the Zapatistas appealed to many political activists outside Mexico.

Our concern in examining the FloodNet codebase, however, is not with its historical setting so much as with two concepts within its form of social activism that are embedded in the code. First, as artists who have worked within the Chicago Dirty New Media and international Glitch Art movements (where #Chicago is a non-locative hashtag), we are fascinated by intentional error as a tactic and specifically by the creative use of 404 errors. These errors present themselves in server logs, where they will eventually be read by a human operator, and are performed, captured, and spread on the client side as an ironic souvenir or token to be passed around. Secondly, we want to foreground the ways in which DDoS as Electronic Civil Disobedience is distinct from malicious DDoS, ways that are embedded in the codebase and the performed actions: activists do not hide their identities and may well sign their names; servers are not anonymized.

Regarding the FloodNet codebase: the source code for the Java applets is missing. The original developers from EDT could not find it. However, opening the .class files in a text editor reveals embedded strings scattered through the non-ASCII, and these strings tell a story. The HTML pages also provide clues, but for the sake of focus, we will dig into the .class files, viewed as texts.

Source for a "developer's kit" version of FloodNet can be downloaded from http://www.thing.net/~rdom/ecd/jan99ddk.zip. FloodNet's Zapatista protest is running in emulation in the Rhizome net.art archive, at https://sites.rhizome.org/anthology/floodnet.html. I have also downloaded the Rhizome HTML and .class files, so we will occasionally cite them.

Lovink, Geert, An Insider's Guide to Tactical Media. from Dark Fiber, MIT Press, 2002, pp. 254-274

cat is a command-line utility that was included in the original 1970s Unix: it reads one or more files from disk and writes all their content out together (con_cat_enates) to the console. It still exists on all Mac and Linux computers today. As the manual page on my Mac laptop says,

The command:

cat file1

will print the contents of file1 to the standard output.

The command:

cat file1 file2 > file3

will sequentially print the contents of file1 and file2 to the file
file3, truncating file3 if it already exists. See the manual page for
your shell (i.e., sh(1)) for more information on redirection.

I want to discuss the version of cat in Plan 9 from Bell Labs, an operating system written to be a 'spiritual successor' to Unix in the 1980s and 1990s (by some of the same people who originally did Unix in the 1970s). The authors of Plan 9 felt that Unix had accumulated "cruft" in the hands of other engineers and researchers and that its "spirit" had been lost. They wanted to excise concepts and subsystems that they felt were outdated or unnecessary. They seemed driven to achieve what they saw as aesthetic unity and clarity.

One of Plan 9's authors said that Plan 9 was meant to be "an argument for simplicity and restraint" -- an operating system as a kind of argument!

cat was a sort of flashpoint or key example for that argument. Before Plan 9, some of its eventual authors gave a presentation, "cat -v Considered Harmful", which criticized the growth of cat under outside organizations like UC Berkeley's Unix research group -- they criticized the addition of features and options like -v to the cat program which had once had a single clear purpose.

So Plan 9's cat (in contrast to Unix's cat) is quite short:

#include <u.h>
#include <libc.h>

void
cat(int f, char *s)
{
    char buf[8192];
    long n;

    while((n=read(f, buf, (long)sizeof buf))>0)
        if(write(1, buf, n)!=n)
            sysfatal("write error copying %s: %r", s);
    if(n < 0)
        sysfatal("error reading %s: %r", s);
}

void
main(int argc, char *argv[])
{
    int f, i;

    argv0 = "cat";
    if(argc == 1)
        cat(0, "<stdin>");
    else for(i=1; i<argc; i++){
        f = open(argv[i], OREAD);
        if(f < 0)
            sysfatal("can't open %s: %r", argv[i]);
        else{
            cat(f, argv[i]);
            close(f);
        }
    }
    exits(0);
}

Even before looking at the code itself, notice that it is so short: 35 lines.
GNU's cat (the descendant of Unix cat used in Linux) is almost 800 lines, and people joke about the difference between the two cats. The brevity of Plan 9's cat (while still providing the basic functionality of cat) is part of the argument: "you don't need all that stuff."

Why are the two programs so different in size? What is omitted in Plan 9 that GNU includes? (right at the top, authorship and copyright information, for instance!) Is everything in GNU really just "cruft"?

What kinds of user and programmer does this Plan 9 argument of simplicity privilege? For instance, the GNU cat claims to be faster (benefitting end users who are using the utility), while the Plan 9 cat may be easier to understand (benefitting programmers who want to learn how the system works). Is it better to have one large program (like GNU cat) that people can learn with many options and features based on what users seem to actually want, or many simple programs (as in Plan 9) that people need to compose together on their own?

Finally, what does the (terse, short variable names, uncommented) code style of Plan 9's cat tell you about the values of its creators? Every line here seems to be written with the assumption that its meaning will be obvious to the reader: for example, it seems to be assumed that the reader will know that f names a file descriptor and that 0 and 1 are standard input and output. Contrast with GNU's cat, which has longer variable names, has extensive comments, and uses input_desc, stdin, and stdout, not f, 0, and 1. But at the same time, overall, isn't GNU's cat still much longer and so more difficult for a reader to understand in full?

1. How does the field of critical code studies draw upon and diverge from feminist decolonial, Indigenous, and queer STS? I wonder what intellectual geneaologies are informing the "critical" in critical code studies?

2. How might the study of source code enable new understandings of the human and the normative body, while also offering possbilities for building alternative ways of knowing and becoming?

In our research, we have found that media sources, as producers of culture, promote an understanding of AI technologies through a language of modernity and progress. For example, media sources promise that AI will be fast, efficient, productive, adaptable, certain, and precise. How does this inform our conceptions of what it means to be valued as human and/or devalued as less than human?

What would an alternative vision of AI technologies look like? Is it possible to imagine a more inclusive AI future with source code that enables slower movement, sideways thinking (Puar), queer use (Ahmed), situated knowledges (Haraway), queer failure (Halberstam)?

• Laura

Most of the time, when one plays games, we may not be explicitly thinking about the underlying code that assembles that game, even though it pervades every facet of that game. I never thought about games as being digital assemblages until I met my first unintended glitch. At the end of a stage in Sonic the Hedgehog 2, if one has collected all of the Chaos Emeralds and still has enough rings (over 50) after passing the end of the stage, if the player jumps, the character sprite, the titular Sonic, will light up and appear to change into his super form. However, he begins running in the air after the end stage screen begins to play. The points are tallied up, and then...nothing. He just keeps running, and the stage never progresses. I was "softlocked," the game not ending but progress completely halted because some condition is not being met, an unrecoverable situation. When this first happened, I was frustrated, thinking the game was broken. I reset the console, and I regained all of my progress after some work.

I learned to play video games before I learned to read. Since my younger years, my brain has often worked through these various systems that I encountered, from planning out my day, to how I can make an intolerable activity more interesting by treating it like a programmed task: assigning points, beating challenges, besting my previous times. It wasn't until a few years after the aforementioned Sonic glitch that I found myself experimenting with glitches intentionally in my playing.

In Pokemon Red/Blue for the Gameboy, there is a series of steps that one can take to make it so one's items in a particular slot in the inventory are multiplied to the game's max value: 256. I learned about this exploit in a gaming magazine, where they laid out all of the steps to do this process, something unintended by the game's developers, GameFreak. I felt like I had broken the rules, replicating items until I had enough to easily level all of my Pokemon to Level 100, the game's maximum level for individual monsters. But it saved me time, and when I linked in (through an analog cable) with my classmates at school, I easily won out. Until the glitch became commonplace.

In performing this glitch, one would encounter the infamous "Missingno.", a glitchy mess of sprite values that looked like a mutant Tetris piece (https://vignette.wikia.nocookie.net/pokemontowerdefense/images/c/ce/Missingno_image.png/revision/latest?cb=20180809204127). The magazine I had read warned not to catch this glitch. It would create a mess of one's save file, and the data would be irretrievable. Now that everyone had maxed out Pokemon, I became curious. I thought back to messing up my game a few years back. I had other copies of Pokemon games from that generation. I traded some of my better Pokemon to other games, and I set about ruining my copy of Pokemon Blue. I caught the Pokemon, and it let out a cry that sounded like mangled copies of the other monsters, randomly bringing up sprites from those other Pokemon. Steadily, my game became unplayable, refusing to even open the last time I tried to activate my game file. I had glitched out my entire experience, and I had to reset the game.

There are a number of reasons for this glitching problem. Ones involves "memory mapping" in those early years of limited memory and storage space. The code used in Gameboy games, often programmed in C and then transferred to binary coding on the cartridges, needed to point to specific locations in order to read what it was supposed to do.

Link to a deconstruction of Pokemon Red: https://github.com/pret/pokered

This glitch, (in)famous for those of us who played it back when, was almost like a rite of passage. Once you'd done what you wanted in the game, this was a way to push the game beyond its intended limits. After that, I found myself seeking out glitches. Could I break through this wall and walk outside of a level? Could I discover something the developers didn't want me to see? Could I crash the game purposefully? In my earlier years, this was somewhat easier, as the exploits were understood through the limited scope of the programming back then. Not to say that exploits aren't possible now (speedrunning communities are dedicated to discovering every unintended coding effect to make the completion of a game faster), but back then there was something ethereal about playing a game both within and without boundaries to the experience.

That's something I'm interested in exploring as I seek to develop games from an indigenous/queer perspective: embracing the glitch. There's something to be explored within "poor programming," or rather, programming within constraints that necessitate a certain cleverness. In the above example, Pokemon Red is a game that is both iconic and incredibly flawed. It operated as intended most of the time, but there were easily exploitable loopholes within the programming that the average gamer could stumble across and eventually foster to create an unintended experience.

As a further example, Pokemon Red was programmed within the bounds of the popular game Minecraft, glitches and all: YouTube exploration () and file (http://www.mediafire.com/file/cbu7gb2p1pbb4cv/Pokemon_Red_-_by_MrSquishy.zip/file). For one, to explore code visually and spatially is amazing (that's a separate topic that I'd like to explore in the future), but the glitches became synonymous with the game. Numerous projects have "patched out" aspects of the game for a more unified experience, but something about it feels..."inauthentic," to borrow a rather disliked and problematic term. The glitch wasn't necessarily beyond the scope of the game: it WAS the game. It was built into the very foundation of the experience; how could it be bad?

As I'm still learning to explore coding, and given the growing but limited support for looking at code from earlier consoles and games, I don't have specific snippets to share from the Pokemon series (though it can be downloaded and played with at your leisure). However, I want to explore ideas of "embracing the glitch," in a way, through developing games. Many contemporary games have employed "glitches" to a degree, though many of these are programmed and very much intended (thinking about the "Doki Doki Literature Club" game; suicide/gore warning to those interested in playing), but glitches, in a broader fashion: could programming practices be made to embrace these ghostly areas of programming? Does "clean coding" and more hierarchical thinking, when it comes to coding, smooth out some of the wrinkles that may prompt later users to play with and explore unintended sides of a gaming experience? Is an intended glitch still a glitch?

I have more thoughts, but I want to leave it here for now.

"Kudzu Ken 20200127 v2" by Frances Van Scoy



Book 2 - General Definitions

Use the serial comma.
Use American dialect.

When play begins:
    Say "This game is one square of a planned 64 square mildly educational game set in the expanded world of Lewis Carroll's [italic type] Through the Looking Glass[roman type].  The anticipated main audience is middle school girls. [paragraph break] [paragraph break]";
    Say "To the west you see a large brick wall with a wooden gate in it. You open the wooden gate and walk through it.  The gate closes behind you.";
    Now the likeability of the player is 2; [Likeability ranges from -5 to +5.]
    Now the left hand status line is "[player's surroundings]";
    Now the right hand status line is "Likeability: [likeability of the player]".

Part 3 - Properties of Things

A knapsack is a container.  A knapsack is wearable. 

Part 1 - Properties of Plants

A person can be known or unknown.

A plant is a kind of person.

A flower is a kind of plant. 

A daisy is a kind of flower.  

A tiger lily is a kind of flower. 

A weed is a kind of plant.

A kudzu_plant is a kind of weed.  The description of a kudzu_plant is "The kudzu seems to be growing as you look at it."
A kudzu_plant is either quiet or active.  A kudzu_plant is usually quiet.
A kudzu_plant is either angry or defeated.  A kudzu_plant is usually angry.
kudzu is a kudzu_plant.

A tree is a kind of plant.

A dogwood is a kind of tree. The description of a dogwood is "Next to the dogwood tree is a sign that says 'cornus florida.'"  

Part 2 - Properties of Player Character

The player has a number called the likeability.

A person is either hostile_to_kudzu or friendly_to_kudzu.
A person is usually friendly_to_kudzu.

The player is wearing a knapsack.  The description of the knapsack is "a canvas bag in which you store items you acquire."

A knife is in the knapsack.  The description of the knife is "a garden knife, suitable for cutting an ear of corn from a cornstalk, for example".

Part 3 - Properties of Non Player Characters

Chapter 1 - Guard Dog Wood (a dogwood tree)

Guard Dog Wood is a tree. The description of Guard Dog Wood is "Guard Dog Wood is an exceptionally large dogwood tree in the middle of the garden." 

Chapter 3 - Dayzee (a daisy)

Dayzee is a flower.  Dayzee is nowhere. 

Chapter 4 - Tigra (a tiger lily)

Tigra is a  flower. Tigra is nowhere.

Chapter 5 - Ken (a kudzu plant)

Ken is a kudzu_plant.  Ken is nowhere.  The printed name of Ken is "a large aggressive kudzu plant".

Part 4 - Facts

A fact is a kind of thing. A fact can be known or unknown. A fact is usually unknown.

Flowers can talk is a fact.

Part 6 - Actions

Understand the command "pick" as something new.
Understand the command "pick" as "take".

Understand "who" as whoing.
Whoing is an action applying to nothing.

Understand "tickle" as tickling.
Tickling is an action applying to nothing.

Understand "help" as helping.
Helping is an action applying to nothing.

Understand "what" as whating.
Whating is an action applying to nothing.

Book 3 - Scenes and Rooms

The player is in the Garden of Live Flowers.

Part 1 - The Scenes

Chapter 1 - Scene Main Garden

Main Garden is a scene.
Main Garden begins when play begins.

When Main Garden begins:
    if Guard Dog Wood is known:
        now Guard Dog Wood is in The Garden of Live Flowers;
    otherwise:
        now Guard Dog Wood is nowhere;
    if Tigra is known:
        now Tigra is in The Garden of Live Flowers;
    otherwise:
        now Tigra is nowhere;

Chapter 2 - Scene  Attack of the Creeper

Attack of the Creeper is a scene.

When Attack of the Creeper begins:
    say "You feel something moving on your leg.  You look and see that a tendril of a kudzu plant is growing rapidly and wrapping itself around your leg.  Almost immediately it reaches your body and begins wrapping itself around you."; 
    now Ken is in the Garden of Live Flowers.

Attack of the Creeper ends badly when Ken is active and Ken is angry.

When Attack of the Creeper ends badly:
    say "The kudzu lets out a horrifying scream, releases its grasp on you and grows to three times its previous size."

Attack of the Creeper ends well when  Ken is defeated.

When Attack of the Creeper ends well:
    Now Ken is in The Garden of Vegetables;
    Now Ken is quiet;
    say "The kudzu struggles for a moment, uproots itself, crawls across the garden, and slides under the gate leading into the Garden of Vegetables    ."

Section 1 - CUTTING a weed

Instead of taking a weed when Attack of the Creeper is happening:
    say "You reach for the kudzu but it moves away from your hand."

Instead of cutting a weed when Attack of the Creeper is happening:
    if player is carrying a knife:
        say "You attempt to cut the kudzu with the knife.";
        now Ken is active;
        now Ken is angry;
    otherwise:
        say "You need to hold a knife in order to cut kudzu."

Section 2 - - TICKLING a weed

instead of tickling when Attack of the Creeper is happening:
    say "The kudzu shakes with laughtern so much that it releases his grip on you.";
    increase the  likeability of the player by 2;
    now Ken is active;
    now Ken is defeated;
    now Ken is in The Garden of Vegetables.


Section 3 - Asking for HELP

[Advice on persuasion isfrom Writin with Infrom, section 12.4 Persuasion, Infor 7 Build 6M62.]

Persuasion rule for asking someone to try helping during Attack of the Creeper:
    if the likeability of the player is greater than 0:
        Say "[the person asked] says to the kudzu, 'Let go of her right now!'";
        if the person asked is Guard Dog Wood:              
            Say "The kudzu releases you.";
            increase the  likeability of the player by 1;
            Now Ken is quiet;
            Now Ken is defeated;
            persuasion succeeds;
        otherwise:
            Say "The kudzu appears to stick out its tongue at [the person asked] and wraps his tendrils more tightly around you.";
            Now Ken is active;
            Now Ken is angry;
    otherwise:
        persuasion fails.

Part 2 - The Rooms

Chapter 1 - Outside the Garden

Outside the Garden is a room.  "To the west you see a large brick wall with a wooden gate in it."


Chapter 2 - The Garden of Live Flowers

The Garden of Live Flowers is a room.  The Garden of Live Flowers is west of Outside the Garden.  "You are in a large walled flower garden. In the center of the garden is a large dogwood tree.  Surrounding the dogwood are many flowers, including  daisies and tiger lilies.   There is also some  kudzu growing in the garden.   [paragraph break] The wooden gate in the brick wall on the east leads to the outside world.  There is no handle on the garden side of the door.  [paragraph break]   You hear a voice say, 'Welcome to the Garden of Live Flowers.'"

In The Garden of Live Flowers are some daisies.   The daisies are scenery.
In The Garden of Live Flowers are some tiger lilies.  The tiger lilies are scenery.

In the Garden of Live Flowers is some kudzu.  The kudzu is scenery.

In the Garden of Live Flowers is a dogwood.  The dogwood is scenery.



Section 1 - GOING east, south, west or north

instead of going east when the player is in the Garden of Live Flowers:
        say "The wooden gate in the brick wall leads to the outside world.  Unfortunately it only opens into the garden, and there is no handle on the garden side of the door." 

before going south:
    say "This garden gate leads to the Garden of Vegetables.  You enter the garden and look around.   [if Ken is in Garden of Vegetables]You notice some kudzu is growing in this garden.[end if]";
    continue the action.

instead of going west when the player is in the Garden of Live Flowers:
        say "That part of the world is still under construction."

instead of going north when the player is in the Garden of Live Flowers:
        say "That part of the world is still under construction."

Section 3 - PICKING flowers

Instead of taking a flower  for the first time: 
        decrease the  likeability of the player by 1;
        say "You think you hear  [the noun] screaming. Some nearby flowers shake, and you think you hear them saying something.  You hear a loud barking sound coming from the center of the garden.  You suddenly think that it might have been a bad idea to try to pick [the noun].";

Instead of taking a flower for the second time:
    decrease the  likeability of the player by 2;
    say "You are startled by a noise from the center of the garden and release [the noun] without picking it.  You look up and see what appears to be an extremely rapidly growing branch coming from the dogwood tree in the middle of the garden.  It stops growing just above your head and then bends down, lifts you from the ground, shakes you and then drops you back onto the garden path."

Instead of taking a flower for at least the third time:
    decrease the likeability of the player by 3;
    say "A large branch of the dogwood tree lifts you from the ground, extends itself over the brick wall, and drops you outside the garden.";
    move the player to Outside the Garden.

Instead of taking a kudzu for the first time:
    now the player is hostile_to_kudzu;
    say "You attempt to pick the kudzu.".

Attack of the Creeper begins when the player is hostile_to_kudzu.

Section 4 - SAYING SORRY

Instead of saying sorry for the first time:
    increase the likeability of the player by 1;
    say "You say, 'I'm awfully sorry!'".

Instead of saying sorry for at least the second time:
    say "Apologizing over and over won't change anything!"

Section 5 - WHOING (asking "who")

Instead of whoing when player is in The Garden of Live Flowers and Guard Dog Wood is unknown :
    say "'Who said that?' you ask. [paragraph break]'I did.  I am Guard Dog Wood.  I live in the Garden of Live Flowers and protect the plants in the garden.'";
    move Guard Dog Wood to the Garden of Live Flowers;
    now the printed name of Guard Dog Wood is "Guard Dog Wood";
    now Guard Dog Wood is known.

Instead of whoing when player is in The Garden of Live Flowers and Guard Dog Wood is known and flowers can talk is unknown  :
    say "'Who said that?' you ask. [paragraph break] 'I did.  My name's Tigra,' says a tall tiger lily as she bends gracefully towards you.  [paragraph break] 'I didn't know flowers could talk!' you say.  'I CAN talk,' says Tigra, 'when there's someone worth talking to.'  [paragraph break] 'We can ALL talk!' say several flowers simultaneously.'";
    move Tigra to the Garden of Live Flowers;
    now flowers can talk is known.


Section 7 - Recognizing speech that contains certain words

[The code in this section is based on Chapter 17 Understanding in Wriitng in  Inform in Build 6M62 of Inform 7 internal documentation. ]


After reading a command:
    if the player's command includes "beauty":
        say "You hear a voice saying 'Thank you!  We think the garden is a beautiful place to live.'";
        reject the player's command;
    if the player's command includes "beautiful":
        say "You hear a voice saying 'Thank you!  We think the garden is a beautiful place to live.'";
        reject the player's command;
    continue the action.

Chapter 4 - The Garden of Vegetables

The Garden of Vegetables is south from the Garden of Live Flowers.

Book 4 - Ending the game

check quitting the game:
    end the story;

When play ends:
    if the story has not ended finally:
        say "Thanks for playing!  For more information about the game, please send email to LookingGlass@juno.com"

Book 5 - Testing

test pick_plant with "who / examine / look / pick daisy / pick daisy / pick daisy / west / pick kudzu /  tickle "

In the Week 1 Introduction to Critical Code Studies we mention Tisselli's piece amazon.html as an example of contemporary code as cultural discourse. Below is an overview and questions on amazon.html, presented in the form of a Working Group code critique for discussion.

Title: amazon.html
By: Euguenio Tisselli
Source: https://twitter.com/motorhueso/status/1157758552662040577
Code: HTML/JavaScript
Date: Aug. 3, 2019
Released via Twitter

Code:

<!doctype html><html><head><meta charset="utf-8"><title>amazon</title><style>body{margin:0;overflow:hidden;}#x{text-align:center;padding-top:30px;}.p{line-height:0.3;display:block;}.q{font-size:2em;font-family:"Courier";letter-spacing:-5px;}</style></head><body><div id="x"></div>

<script>var s=5e3;var c=["#37ae3c","#236e12","#7bab2e"];var x=document.getElementById("x");function g(y){return ~~(Math.random()*y);}var i=60;while(i--){var d=document.createElement("DIV");d.className="p";var j=50;while(j--){var t=document.createElement("SPAN");t.className="q";

http://t.style.color=c[g(c.length)];t.textContent="*";d.appendChild(t);}x.appendChild(d);}function m(){var e=x.children[g(x.children.length)];var f=e.children[g(e.children.length)];http://f.style.color="#795548";f.textContent=String.fromCharCode(g(10)+48);

s=s>100?s-100:10;setTimeout(m,s);}setTimeout(m,s);</script></body></html>

Overview

On August 3rd, 2019, Euguenio Tisselli posted “amazon.html”: a series of four plaintext code fragments of HTML with embedded JavaScript, all published as a single Twitter thread,[¹] along with instructions:

copy the following code (all of it, follow the thread), paste it on a plain text editor, save it as 'amazon.html', double click on the file so it shows in your browser... and watch #capitalocene unfold before your eyes!
#visual #code #poetry

https://twitter.com/motorhueso/status/1157758552662040577

Individually, each fragment does nothing. When one does assemble the fragments and run amazon.html in a contemporary web browser[²] the result is a large field of hundreds of asterisk characters of varying shades of green, evoking map or satellite view of a forest. Very slowly, green characters are replaced with brown numerals. Over time the process accelerates, until only a field of shifting numbers remains.

In his tweet thread, Tisselli also linked to a page where “you can see it live” (http://motorhueso.net/amazon/), however that page also did not present the running code. Instead, it offered the same code as a single text block of HTML with embedded JavaScript (a one-liner, in fact, labeled “length: 873 bytes”) along with similar instructions to cut, paste, save, and run.[³] The reader is asked to do this in order to witness what the code performs.[⁴]

Both sources (the Twitter thread and the hosting webpage) contain similar commentaries on contexts of meaning for amazon.html. The thread contains a photo of Amazon rainforest clearcutting, along with a quote on the “tipping point” of deforestation; the webpage simply links to the source 2019 EcoWatch article “Amazon Deforestation Rate Hits 3 Football Fields Per Minute, Data Confirms” while providing additional artist’s commentary on what it means to “watch the capitalocene unfold before your eyes” -- and on the role of algorithm and code in the piece.

what is destroying the forest? it is the capitalist algorithm, executed by fascist war-men/machines. remove the algorithm from bodies and minds, smash the killer machines!

code is the vector that transforms your desires into data // code extracts desires from your body, delivers them to the machine, and transports them through the full stack // code is what connects your infinite boredom to the tragedy of burning forests

Due to the nature of the piece, the code is available in three forms: as fragments, as a one-liner, and as a user-generated file necessary for the piece to run. In all cases, the code is pre-minified or compressed, as is common in both commercial HTML+JavaScript and in aesthetic code art / play practices such as quines, esoteric languages, and code golf. An interesting aspect of this minification is that it is unlikely (although not impossible) that Tisselli actually composed or revised the code in this form. Instead, there might be (or might have been) an original author’s source code that was later minified before being published. [Edit: In fact, the code was authored in minified form.]

Minified code, however, may be difficult to read (and annotate). It can largely be reversed by running it through parsers to add white space and unpack dense structures for each of the three syntax types in the document: HTML, CSS, and JavaScript. [⁵] A resulting decompressed form of amazon.html looks like this:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>
      amazon
    </title>
    <style>
      body {
        margin: 0;
        overflow: hidden;
      }
      #x {
        text-align: center;
        padding-top: 30px;
      }
      .p {
        line-height: 0.3;
        display: block;
      }
      .q {
        font-size: 2em;
        font-family: "Courier";
        letter-spacing: -5px;}
    </style>
  </head>
  <body>
    <div id="x"></div>
    <script>
      var s = 5e3;
      var c = ["#37ae3c", "#236e12", "#7bab2e"];
      var x = document.getElementById("x");
      function g(y) {
          return ~~(Math.random() * y);
      }
      var i = 60;
      while (i--) {
          var d = document.createElement("DIV");
          d.className = "p";
          var j = 50;
          while (j--) {
              var t = document.createElement("SPAN");
              t.className = "q";
              t.style.color = c[g(c.length)];
              t.textContent = "*";
              d.appendChild(t);
          }
          x.appendChild(d);
      }
      function m() {
          var e = x.children[g(x.children.length)];
          var f = e.children[g(e.children.length)];
          f.style.color = "#795548";
          f.textContent = String.fromCharCode(g(10) + 48);
          s = s > 100 ? s - 100 : 10;
          setTimeout(m, s);
      }
      setTimeout(m, s);
    </script>
  </body>
</html>

Questions for Discussion

How to approach such code, and what to ask about it?

• We could question its form of representation and related idioms (ASCII art, helicopter and satellite photography, et cetera).
• We could what it is and does -- is it random, is it interactive, does it change continuously or in stages, what is its model and/or what is it modeling, et cetera.
• We could talk about its aesthetics -- at run time, in its presentation, and in the way it was coded / composed.
• We could consider its intertextual references -- the related EcoWatch and Guardian articles, as well as whether its form is inspired by, an homage to, or borrowed / taken ready-made from other prior code.
• We might consider it in the context of other work by Tisselli, or other discourse on the capitaloscene.
• We could investigate about the relationships between the processes the user must perform to run the code and the code processes.
• We could consider audience and platform: for example, can amazon.html be composited, saved, and loaded easily on a contemporary smartphone, or is it primarily accessible only to laptop users, and if so how does that relate to its dissemination through Twitter?
• We might also consider questions of preservation, archiving, and dissemination. If this piece is worth talking about, is it worth keeping accessible three years, ten years, or fifty years from now? What would that accessibility look like, and what do the roles of artists, commentators, or scholars look like in that process?
• Finally, what might any of this tell us about how amazon.html relates to the Amazon rainforest, deforestation, the capitaloscene, or algorithmic culture more broadly?

Amazon rainforest clearcutting photo tweeted by Tiisselli.

So here is an example of Hydra, a JavaScript-based language for visuals developed by Olivia Jack which does a wonderful job imitating old school multichannel video synthesis. This was written by Flor De Fuego. Its result can be run here (which remains editable in browser).

• Title: Let The Chaos Rule the Rest
• Author: Flor De Fuego
• Language: Hydra (authored by Olivia Jack)
• Year: 2019

    //Flor de Fuego 
    osc(300,0.1) .contrast(3) .diff(osc(3000,0.1).rotate(5),1) .modulateScale(osc(3,0.1).kaleid(200),-0.9) 
    .modulateScale(osc(6,0.1).rotate(11).kaleid(-200),0.5) .mult(osc(1,0).kaleid(200).scrollX(0.1).scrollY(-0.1),0.8) 
    .blend(shape(200,0.01).scale(0.5,0.5).color(1,0,0) 
    .add(shape(4,0.1).color(1,0,0).scale(0.5,0.5).scrollX(()=>Math.sin(1*time)*0.26),1).rotate(0,0.8) 
    .add(shape(200,0.1).scale(0.5,0.5).scrollX(()=>Math.sin(1*time)*-0.47).color(0,0,1),1),0.5).rotate(0,0.5) 
    .mult(shape(200,0.01).scale(0.5,0.5) 
    .add(shape(4,0.1).color(1,0.5,1).scale(0.5,0.5).scrollX(()=>Math.sin(1*time)*0.26),1).rotate(0,0.8) 
    .add(shape(200,0.1).scale(0.5,0.5).scrollX(()=>Math.sin(1*time)*-0.47),1)).rotate(0,0.5) 
    //.color(1,[0,1],[0,1]) .rotate(0,0.8) .modulateRotate(osc(2),-1) .saturate([3,4,5,6,10].fast(8))
.diff(src(o0).modulateScale(osc(()=>Math.sin(1*time)*20,0.5),0.03).scrollX(()=>Math.sin(1*time)*0.001).scrollY(()=>Math.sin(1*time)*-0.001)) .modulate(o0,()=>Math.sin(1*time)*0.0001) .mult(shape(4,1).scrollY(-1).modulateScale(osc(3,0.5),-0.5)) .luma(0.1) //.add(src(o0).scrollX(0.01),0.001) //.mult(src(o0),0.01) //.luma(2) .out()

Here is another example, written by Flor and Zach Krall in collaboration. Its result can be seen here (which remains editable in browser).

• Untitled
• Authors: Flor De Fuego and Zach Krall
• Language: Hydra (authored by Olivia Jack)
• Year: 2019

                osc(8,-0.1).color(1,1,1.3).scrollY(1,0.1)
                .modulate(osc(10,0.5).modulate(noise(2)))
                .modulate(noise(20,-1))
                .modulateRotate(noise(10,0.1))
                .modulate(osc(8,0.1)
                .modulate(noise(2))).modulate(o0,0.05)
                .modulate(o1,1).out()
                noise(3,0.1).modulate(noise(1),1)
                .contrast(5).modulateRotate(o1)
                .modulate(o1,1).out(o1)

I'd be happy to to discuss the ins and outs of the code (here is the Hydra Github and master function list), but wanted to mention a couple ancillary thoughts-

One of my favorite things about Hydra is the upload button in the web-based version, which sends whatever you’re working on to the Hydra Patterns Twitter Bot, where then anyone in the world can click, and then edit your code, and then publish their version based on yours, all with attribution. I have never met Flor in-person, whose code is above, yet this language brought us together. Likewise, Zach and Flor collaborated on this code across thousands of miles without having yet met in-person.

This is a little bit of a personal aside, but as I’ve become a participant in the livecode/algorave scene, one of my favorite things about it has been an emerging political context, particularly among audience members. Several times I’ve met “disaffected tech workers” who wanted to come see livecoding to “see what could be created with the same tools” that aren’t in the service of big corporate tech. As a programmer who had just left Facebook recently said to me at a recent show “I’d rather create algorithms that make people dance than chase the monetization of data to political and social destruction.”

Author: Samara Hayley Steele

Language: RPG Code / Development Practice

Year/s of development: 2018-2019

About: A number of analog RPGs may be thought of as code that runs on humans. The goal of this project is to create an environment in which players/users co-create analog code and run it.

Software/hardware/wetware requirements:

• Humans. Minimum of 3 players. Works best with around 20. You probably don't want to go much higher than 50.
• Notecards
• Sticky Notes (aka "Post-it Notes")
• Pencils
• (optional) 3-10 black masks. If no black masks are available, matching capes could also work.
• (optional) An hour glass with about 1-2 minutes worth of sand
• Random Objects (for example):
  1. a drum
  2. a pair of sunglasses
  3. a pile of 3-10 ambiguously shaped felt scapes (felt is a type of cloth), preferably large enough to stand on

Warm up (3-5 min):

"Hello everyone! I would like to invite you all to play a rulesmithing game."
Go around the room and give each player 2 sticky notes, 1 notecard, and distribute pencils.

"First I would like you all to write a gender neutral noun on your notecard. It can be any noun, just be sure to pick one that is gender neutral." 

Once they have thought up and written down their gender neutral nouns, ask them to write the same noun on one of their sticky notes.  

Next, ask them to use their remaining sticky note to draw a room. "It can be any room. Any type of room that you might find in a building.  A kitchen or a bathroom or a library or a lobby.  Any type of room is okay." 

Give them a minute or so to draw their rooms.

Now, ask them to walk around whatever space you are in, and have them place their room somewhere. Some of them might put their room on a wall.  Others might put it on a the floor.  Everywhere is okay.

Next, ask them all to hand you their notecards. (The notecards should by now each have a gender neutral-noun written on them.)

Now, ask them to place the remaining sticky note (which should have the same noun on it) on their chests.

Rulesmithing (4 min):

Break everyone into 2-3 groups of roughly the same size

Take your Random Objects (for example, a drum, a pair of sunglasses, a pile of felt scrapes) and place them on the ground. Be sure there's about 4 strides of space between each pile.

Assign each group to one of the piles. 

"Your job, as a group is to figure out what this thing, or pile of things, does.  For example, maybe when I touch this drum, it lets me fly. Or makes me invisible. Or... you get the idea."

Have them work together to figure out what their group's object (or pile) does. Be sure to give them a 1-minute warning to wrap up.

Teaching Each Other the Rules (5 min):

"All right. We're going to teach each other the rules we've just made." 

Have each group demo their rule to the rest of the group. Then, have everyone in the group try try the rule out.  Make sure they each actually demonstrate that they get the rule. If they don't seem to be getting it, have the others help them.

If a rule seems like it won't get properly distributed, you may choose to step in and modify it. (For example, let's say a group creates a cool rule for a single pair of sunglasses. To make sure that one person doesn't hoard them once the game starts, you can bring out the hourglass and say "A player may only wear the sunglasses for the length of time measured by this hourglass.  If you are wearing the sunglasses, be sure to hold hour glass and measure your time. Once the hour glass runs out, you have to put the sunglasses and hour glass on the ground and walk away from them."

Once everyone seems to have a good idea of how the rules/objects work, time to start the RPG (roleplaying game).

The RPG (7-20 min):

"We are going to play a short game, in which we play characters in an alternate universe. Look at the sticky note on your chest: that is your character's name. 

"We are in a place called "The Institution." It is a very big place.  Remember that room you drew earlier? That room is part of the Institution. And your character is the leading expert about that room."

"In a few minutes, we are going to get into character, and when I call your character's name, it will be their turn to guide everyone to their room and to tell them about it."

"In the mean time, all the rules we have just created with these objects will be in effect. Be sure to help each other if someone has forgotten how the rules work."

"Also, sometimes you'll hear me speak as a voice from the PA system. "testing, testing""

"Everyone, look down at the sticky now on your chest. That is your character's name."

Time to start the game:

"And now we're going to become our characters. Please get into character."

Use your PA voice to start the game. "Welcome to the Instution. Today you will all be giving each other tours of your rooms." Grab a random note card from your pile ad read the name. "[Name] will be offering the first room tour."

As they go, be sure they are using the rules they've created. It's okay if the tour is constantly being interrupted and derailed, as long as they are engaging with the rules they've designed.

Every few minutes, depending on how much time you have, use your "PA system voice" to call upon a new person over to guide everyone to their room and give a tour.

--Optional: Enter the Rule Enforcers (5-10 minutes)--

One they've gotten into a flow of using the rules, pause the game.

Ask: "Who feels pretty confident that you understand how the rules work?" (show of hands)

The first 2-7 hands that go up, give them a black mask.

"Everyone who has a black mask on is now a Rule Enforcer. Your job is to scan the room and make sure that everyone else is following the rules properly."

"Alright everyone, we are going to go back to playing.  The next tour should be given by..."

When it is time for the game to end, use your "PA announcer voice" to make some sort of statement.  Perhaps, something darkly funny like: "It is now time for the Institution to close.  You have all done very well today. Please relocate to your transport methods and vacate the premises or you will be vaporized by security. Repeat: Please relocate to your transport methods and vacate the premises or you will be vaporized by security."

Debrief (5-7 min):

"All right everyone! The game is officially over. I need everyone to help out with clean up!" Remind everyone we are out-of-character now. 

Ask everyone to help put the Random objects away and game items away.

Once the space has been restored to its normal/clean form, circle up for a short debrief.

Debrief questions:

• "What was the most interesting moment in the game for you? What was the most fun?"
• "We just created a set of rules and wandered around in a reality in which they are supposedly real. But we all know they aren't real, because we created them together. How did it feel to be in that kind of space? Did the rules ever start to feel real? If so, what made them feel real?"
• (If there were enforcers) "Did the game change once there were enforcers? Was there anything different about that part of the game for you?"
• "Do you think there might be things in the actual so-called "real world" that aren't quite "real" as well? If so, what kinds of things do you suspect might be the result of a set of social agreements?" If you have a whiteboard, write down what they say. Types of things to include: gender, race, nature, the economy. "How are these things so-created? Let's talk through this."
  1. "What kinds of objects do we treat as if they are these things?" (Examples might include "melanin in a person's skin" "genital configurations" "stock ticker numbers" "plants" "animals")(be sure to ask complicating questions like, "Is your pet dog part of nature? Why not?" or "Is your elbow the thing that gives you gender? Why not?")
  2. "What kinds of social practices are used to make sure everyone keeps treating these objects that way?"

"Thanks everyone!"

Follow-up writing prompt:

Today we created a set of social rules around a bunch of random objects. But in the "real world," objects are also used as the center pieces for a set of social rules. What's the different between the game we played today, and those social rules in the "real world"? Could we call those real world rules "a game"? Why or why not? What kinds of experiences have you had based on "real world" objects like these? Were they good experiences? Why or why not?

Follow-up reading:

• Dark Matters "Introduction" by Simone Browne
• The New Jim Code by Ruha Benjamin
• Gender Trouble by Judith Bulter
• Take Back the Economy by J.K. Gisbon Graham
• Any RPG rulebook, such as Dungeons and Dragons or something from the White Wolf series.
• "Ideology and Ideological State Apparatuses" by Louis Althusser
• "Reification" from History and Class Consciousness by György Lukács

Artist's Statement

I have now performed “Realitycraft: an RGP Rulesmithing Game” twice, as part of mini-conferences for the UC Davis Performance Studies Department in Dec 2019, and as part of a workshop in late 2018.

My goal with this piece is to simultaneously offer a demonstration of what I call “RPG rulesmithing” or the act of creating intradiegetic objects, while also providing a demonstration of some basic tenants of the RPG medium. With this piece, I also aim to offer a material intervention into the normalization of reified economy, gender, race, and other "non-fiction" diegetic systems that, at times, find themselves congealed into material objects. Rulesmithing, and the adjacent theory of intradiegetic objects, draws upon and modifies certain theoretical investments of Judith Butler, Louis Althusser, J.K. Gibson-Graham, and Gerard Genette.

Rulesmithing, as method, aims to engender fluency in the co-creation of the mutually agreed upon conditions of narrative reality. This mode of fluency I see as liberatory as it allows a re-enchantment of materialities that had previously been subjected to enclosure. This is to say, the ultimate goal of this piece is to facilitate an environment in which participants are engaging in behaviors that might productively be compared to the craft of law, gender, race, and capital while likewise maintaining a focus upon the act of crafting, rather than allowing craft to be invisiblized.

Also, as a feature of this piece, I avoid evoking terms pertaining to specific sets of systematized asymmetrical power relations (capital, gender, race, etc) until the discussion after the piece has been performed. This is because these terms and concepts have been heavily politicized (by virtue of the very asymmetrical power relations that allows their reification to maintains veridicality) and thus may trigger feelings from lived power-relations that, if evoked, may lead participants to foreclose upon engaging with the piece before it begins.

Photographic Documentation (from Nov. 22, 2019 run):

Stephanie Strickland and I wrote of a specific part of the Sea and Spar Between code: “The following syllables, which were commonly used as words by either Melville or Dickinson, are combined by the generator into compound words.” This particular way of conflating Melville’s language with Dickinson’s was important to us. However, due to a programming error, it wasn’t being done. What was line 255 in version 1:

syllable.concat(melvilleSyllable);

does not accomplish the purpose of adding the Melville one-syllable words to the variable syllable, which holds an array of Dickinson’s words at this point. The concatenation happens, but the concat() method does not change the syllable array in place. The resulting longer list is simply thrown away. This line has been changed in version 1.0.1, published yesterday. The relevant line, because of the addition of explanatory comments, is now line 286:

syllable = syllable.concat(melvilleSyllable);

I noticed this omission myself only years after the 2013 publication of cut to fit the toolspun course, a richly commented edition of Sea and Spar Between. As a result of my mistake, the compound or kenning “toolspun,” used in the title of that work, never was actually produced in any existing version of Sea and Spar Between. This was a frustrating situation, but after Stephanie and I discussed it briefly, we decided that we would wait to consider releasing an updated version until this defect was discovered by someone else, such as a critic or translator.

The system has been translated to Polish and has been “remixed” once that we know of. The ELMCIP database lists 20 references to Sea and Spar Between in critical writing.

The defect was only discovered recently by a critic, Aaron Pinnix, a Fordham PhD student doing a dissertation on oceanic literary works.

The cut to fit the toolspun course edition of the project (incorrectly given the title “cut to fit the tool-spun course” in the journal Digital Humanities Quarterly when it was published) is less than 1000 lines long, not lengthy for an academic paper on electronic literature. This may be the most detailed discussion of a digital literary system’s code by the authors of that system.

Yet Pinnix discovered the mistake simply by carefully reading the system’s output and carefully reading statements that Strickland and I made about how the system was supposed to work; there was no tracing through the code and no CCS analysis done. It seems that a thorough and attentive traditional reading, in this case, led to the most complete understanding of how this system works so far.

Since Kenner and O'Rourke first shared Travesty by publishing it in Byte Magazine, I thought it would be interesting to take a closer look at what the code does. Does it demonstrate some ideas about the original text it works on? Since the term "travesty" is pretty dramatic, is there evidence in what it's doing that validates that idea of what it's doing to the text? Is what goes on in Travesty truly similar to processes that we think of as its descendants (Markov chain and char-rnn, mainly), or is something else at work?

Travesty is written in Pascal, a language I don't have any prior experience with. Still, getting it to run was pretty straightforward. I've transcribed it line by line (including comments) from Byte and shared it in a Github repository, along with some instructions on using it.

Since the directions say to post the code you're critiquing in your thread, I'll include it here as well. I'll post some initial thoughts in a reply to this thread.

Listing 1: Travesty, a program for generating pseudo-text. The program will scan a sample text and generate a "nonsense" imitation. For an order-n scan, every n-character sequence in the output occurs somewhere in the input.

\n
\n
PROGRAM travesty (input,output);            { Kenner/ O'Rourke, 5/9/84}

(*     This is based on Brian Hayes' article in Scientific           *)
(*     American, November 1983. It scans a text and generates        *)
(*     an n-order simulation of its letter combinations. For         *)
(*     order n, the relation of output to input is exactly:          *)
(*           "Any pattern n characters long in the output            *)
(*               has occurred somewhere in the input,                *)
(*                 and at about the same frequency."                 *)
(*     Input should be ready on disk. Program asks how many           *)
(*     characters of output you want. It next asks for the           *)
(*     "Order" -- i.e. how long a string of characters will be       *)
(*     cloned to output when found. You are asked for the            *)
(*     name of the input file, and offered a "Verse" option.         *)
(*     If you select this, and if the input has a "|" char-          *)
(*     acter at the end of each line, words that ends lines in       *)
(*     the original will terminate output lines. Otherwise,          *)
(*     output lines will average 50 characters in length.            *)

CONST 
  ArraySize = 3000;       {maximum number of text chars}
  MaxPat = 9;        {maximum Pattern length}

VAR
  BigArray : PACKED ARRAY [1..ArraySize] of CHAR;
  FreqArray, StartSkip : ARRAY[' '..'|'] of INTEGER;
  Pattern : PACKED ARRAY [1..MaxPat] of CHAR;
  SkipArray : ARRAY [1..ArraySize] of INTEGER;
  OutChars : INTEGER;    {number of characters to be output}
  PatLength : INTEGER;
  f : TEXT;
  CharCount : INTEGER; {characters so far output}
  Verse, NearEnd : BOOLEAN;
  NewChar : CHAR;
  TotalChars : INTEGER; {total chars input, + wraparound}
  Seed : INTEGER;

FUNCTION Random (VAR RandInt : INTEGER) : REAL;
BEGIN
  Random := RandInt / 1009;
  RandInt := (31 * RandInt + 11) MOD 1009
END;

PROCEDURE InParams;
  (* Obtains user's instructions *)
VAR
  InFile : STRING [12];
  Response : CHAR;
BEGIN
  WRITELN ('Enter a Seed (1..1000) for the randomizer');
  READLN (Seed);
  WRITELN ('Number of characters to be output?');
  READLN (OutChars);
  REPEAT
    WRITELN ('What order? <2-', MaxPat,'>');
    READLN (PatLength)
  UNTIL (PatLength IN [2..MaxPat]);
  PatLength := PatLength - 1;
  WRITELN ('Name of input file?');
  READLN (InFile);
  ASSIGN (f, InFile);
  RESET (f);
  WRITELN ('Prose or Verse? <p/v>');
  READLN (Response);
  IF (Response = 'V') OR (Response = 'v') THEN
    Verse := true
  ELSE Verse := false
END; {Procedure InParams}

PROCEDURE ClearFreq;
(*  FreqArray is indexed by 93 probable ASCII characters,            *)
(*  from " " to "|". Its elements are all set to zero.               *)
VAR
  ch : CHAR;
BEGIN
  FOR ch := ' ' TO '|' DO
    FreqArray[ch] := 0
END; {Procedure ClearFreq}

PROCEDURE NullArrays;
(* Fill BigArray and Pattern with nulls *)
VAR
  j : INTEGER;
BEGIN
  FOR j := 1 TO ArraySize DO
    BigArray[j] := CHR(0);
  FOR j := 1 TO MaxPat DO
    Pattern[j] := CHR(0)
END; {Procedure NullArrays}

PROCEDURE FillArray;
(*    Moves textfile from disk into BigArray, cleaning it            *)
(*    up and reducing any run of blanks to one blank.                *)
(*    Then copies to end of array a string of its opening            *)
(*    characters as long as the Pattern, in effect wrapping          *)
(*    the end to the beginning.                                      *)
VAR
  Blank : BOOLEAN;
  ch: CHAR;
  j: INTEGER;

  PROCEDURE Cleanup;
  (* Clears Carriage Returns, Linefeeds, and Tabs out of            *)
  (* input stream. All are changed to blanks.                       *)
  BEGIN
    IF ((ch = CHR(13))     {CR}
      OR (ch = CHR(10))   {LF}
      OR (ch = CHR(9)))  {TAB}
    THEN ch := ' '
  END;

BEGIN {Procedure FillArray}
  j := 1;
  Blank := false;
  WHILE (NOT EOF(f)) AND ( j <= (ArraySize - MaxPat)) DO
  BEGIN {While Not EOF}
    READ (f,ch);
    Cleanup;
    BigArray[j] := ch;                    {Place character in BigArray}
    IF ch = '' THEN Blank := true;
    j := j + 1;
    WHILE (Blank AND (NOT EOF(f))
      AND (j <= (ArraySize - MaxPat))) DO
    BEGIN {While Blank}                    {When a blank has just been}
      READ (f,ch);                            {printed, Blank is true,}
      Cleanup;                      {so succeeding blanks are skipped,}
      IF ch <> '' THEN                            {thus stopping runs.}
      BEGIN {If}
        Blank := false;
        BigArray[j] := ch;                 {To BigArray if not a Blank}
        j := j + 1
      END {If}
    END {While Blank}
  END; {While Not EOF}
  TotalChars := j - 1;
  IF BigArray[TotalChars] <> '' THEN
  BEGIN   {If no Blank at end of text, append one}
    TotalChars := TotalChars + 1;
    BigArray[TotalChars] := ' '
  END;
  {Copy front of array to back to simulate wraparound.}
  FOR j := 1 TO PatLength DO
    BigArray[TotalChars + j] := BigArray[j];
  TotalChars := TotalChars + PatLength;
  WRITELN('Characters read, plus wraparound = ',TotalChars:4)
END; {Procedure FillArray}

PROCEDURE FirstPattern;
(* User selects "order" of operation, an integer, n, in the          *)
(* range 1 .. 9. The input text will henceforth be scanned           *)
(* in n-sized chunks. The first n-1 characters of the input          *)
(* file are placed in the "Pattern" Array. The Pattern is            *)
(* written at the head of output.                                    *)
VAR
  j : INTEGER;
BEGIN
  FOR j := 1 TO PatLength DO           {Put opening chars into Pattern}
    Pattern[j] := BigArray[j];
  CharCount := PatLength;
  NearEnd := false;
  IF Verse THEN WRITE (' ');   {Align first line}
  FOR j := 1 TO PatLength DO
    WRITE (Pattern[j])
  END; {Procedure FirstPattern}

PROCEDURE InitSkip;
(*   The i-th entry of SkipArray contains the smallest index         *)
(*   j > i such that BigArray[j] = BigArray[i]. Thus SkipArray       *)
(*   links together all identical characters in BigArray.            *)
(*   StartSkip contains the index of the first occurrence of         *)
(*   each character. These two arrays are used to skip the           *)
(*   matching routine through the text, stopping only at             *)
(*   locations whose character matches the first character           *)
(*   in Pattern.                                                     *)
VAR
  ch : CHAR;
  j : INTEGER;
BEGIN
  FOR ch := ' ' TO '|' DO
    StartSkip[ch] := TotalChars + 1;
  FOR j := TotalChars DOWNTO 1 DO
  BEGIN
    ch := BigArray[j];
    SkipArray[j] := StartSkip[ch];
    StartSkip[ch] := j
  END
END; {Procedure InitSkip}

PROCEDURE Match;
(*   Checks BigArray for strings that match Pattern; for each        *)
(*   match found, notes following character and increments its       *)
(*   count in FreqArray. Position for first trial comes from         *)
(*   StartSkip; thereafter positions are taken from SkipArray.       *)
(*   Thus no sequence is checked unless its first character is       *)
(*   already known to match first character of Pattern.              *)
VAR
  i : INTEGER;     {one location before start of the match in BigArray}
  j : INTEGER; {index into Pattern}
  Found : BOOLEAN;      {true if there is a match from i+1 to i+j - 1 }
  ch1 : CHAR;       {the first character in Pattern; used for skipping}
  NxtCh : CHAR;
BEGIN {Procedure Match}
  ch1 := Pattern[1];
  i := StartSkip[ch1] - 1;         {is is 1 to left of the Match start}
  WHILE (i <= TotalChars - PatLength - 1) DO
  BEGIN {While}
    j := 1;
    Found := true;
    WHILE (Found AND (j <= PatLength)) DO
      IF BigArray[i+j] <> Pattern[j]
        THEN Found := false   {Go thru Pattern til Match fails}
        ELSE j := j + 1;
      IF Found THEN
      BEGIN            {Note next char and increment FreqArray}
        NxtCh := BigArray[i + PatLength + 1];
        FreqArray[NxtCh] := FreqArray[NxtCh] + 1
      END;
      i := SkipArray[i + 1] - 1  {Skip to next matching position}
    END {While}
  END; {Procedure Match}

PROCEDURE WriteCharacter;
(*   The next character is written. It is chosen at Random           *)
(*   from characters accumulated in FreqArray during last            *)
(*   scan of input. Output lines will average 50 character           *)
(*   in length. If "Verse" option has been selected, a new           *)
(*   line will commence after any word that ends with "|" in         *)
(*   input file. Thereafter lines will be indented until             *)
(*   the 50-character average has been made up.                      *)
VAR
  Counter, Total, Toss : INTEGER;
  ch : CHAR;
BEGIN
  Total := 0;
  FOR ch := ' ' TO '|' DO
  Total := Total + FreqArray[ch]; {Sum counts in FreqArray}
  Toss := TRUNC (Total * Random(Seed)) + 1;
  Counter := 31;
  REPEAT
    Counter := Counter + 1;                         {We begin with ' '}
    Toss := Toss - FreqArray[CHR(Counter)]
    until Toss <= 0;                                   {Char chosen by}
  NewChar := CHR(Counter);                    {successive subtractions}
  IF NewChar <> '|' THEN
    WRITE (NewChar);
  CharCount := CharCount + 1;
  IF CharCount MOD 50 = 0 THEN NearEnd := true;
  IF ((Verse) AND (NewChar = '|')) THEN WRITELN;
  IF ((NearEnd) AND (NewChar = ' ')) THEN
  BEGIN {If NearEnd}
    WRITELN;
    IF Verse THEN WRITE ('     ');
    NearEnd := false
  END {If NearEnd}
END; {Procedure Write Character}

PROCEDURE NewPattern;
(*   This removes the first character of the Pattern and             *)
(*   appends the character just printed. FreqArray is                *)
(*   zeroed in preparation for a new scan.                           *)
VAR
  j : INTEGER;
BEGIN
  FOR j := 1 to PatLength - 1 DO
    Pattern[j] := Pattern[j + 1];             {Move all chars leftward}
  Pattern[PatLength] := NewChar;                       {Append NewChar}
  ClearFreq
END; {Procedure NewPattern}

BEGIN {Main Program}
  ClearFreq;
  NullArrays;
  InParams;
  FillArray;
  FirstPattern;
  InitSkip;
  REPEAT
    Match;
    WriteCharacter;
    NewPattern
  UNTIL CharCount >= OutChars;
END. {Main Program}

The Anecdote

Bill Atkinson worked mostly at home, but whenever he made significant progress he rushed in to Apple to show it off to anyone who would appreciate it. This time, he visited the Macintosh offices at Texaco Towers to show off his brand new oval routines in Quickdraw, which were implemented using a really clever algorithm.

Bill had added new code to QuickDraw (which was still called LisaGraf at this point) to draw circles and ovals very quickly. That was a bit hard to do on the Macintosh, since the math for circles usually involved taking square roots, and the 68000 processor in the Lisa and Macintosh didn't support floating point operations. But Bill had come up with a clever way to do the circle calculation that only used addition and subtraction, not even multiplication or division, which the 68000 could do, but was kind of slow at.

Bill's technique used the fact the sum of a sequence of odd numbers is always the next perfect square (For example, 1 + 3 = 4, 1 + 3 + 5 = 9, 1 + 3 + 5 + 7 = 16, etc). So he could figure out when to bump the dependent coordinate value by iterating in a loop until a threshold was exceeded. This allowed QuickDraw to draw ovals very quickly.

Bill fired up his demo and it quickly filled the Lisa screen with randomly-sized ovals, faster than you thought was possible. But something was bothering Steve Jobs. "Well, circles and ovals are good, but how about drawing rectangles with rounded corners? Can we do that now, too?"

"No, there's no way to do that. In fact it would be really hard to do, and I don't think we really need it". I think Bill was a little miffed that Steve wasn't raving over the fast ovals and still wanted more.

Steve suddenly got more intense. "Rectangles with rounded corners are everywhere! Just look around this room!". And sure enough, there were lots of them, like the whiteboard and some of the desks and tables. Then he pointed out the window. "And look outside, there's even more, practically everywhere you look!". He even persuaded Bill to take a quick walk around the block with him, pointing out every rectangle with rounded corners that he could find.

When Steve and Bill passed a no-parking sign with rounded corners, it did the trick. "OK, I give up", Bill pleaded. "I'll see if it's as hard as I thought." He went back home to work on it.

Bill returned to Texaco Towers the following afternoon, with a big smile on his face. His demo was now drawing rectangles with beautifully rounded corners blisteringly fast, almost at the speed of plain rectangles. When he added the code to LisaGraf, he named the new primitive "RoundRects". Over the next few months, roundrects worked their way into various parts of the user interface, and soon became indispensable.

The Code

Author: Bill Atkinson
Year: 1981

QuickDraw is the Macintosh library for creating bit-mapped graphics, which was used by MacPaint and other applications. It consists of a total of 17,101 lines in 36 files, all written in assembler language for the 68000.

This is the RRects code which contains the functions for the new primitive "RoundRects". We now take these for granted in the Mac and iOS interfaces, but they started out here. I thought it would be interesting to try to deconstruct this code which is extremely tightly written to see if we can see the beginnings of a user interface primitive that has become so iconic (look at your display!). The full code for QuickDraw is here.

               .INCLUDE  GRAFTYPES.TEXT

;-----------------------------------------------------------
;
;
;     ****   ****   *****   ***   *****   ***
;     *   *  *   *  *      *   *    *    *   *
;     *   *  *   *  *      *        *    *
;     ****   ****   ***    *        *     ***
;     * *    * *    *      *        *        *
;     *  *   *  *   *      *   *    *    *   *
;     *   *  *   *  *****   ***     *     ***
;
;
;  procedures for operating on RoundRects.
;
;

    .PROC StdRRect,4
    .REF  CheckPic,DPutPicByte,PutPicVerb,PutPicLong,PutPicRect
    .REF  PutOval,PushVerb,DrawArc
;---------------------------------------------------------------
;
;  PROCEDURE StdRRect(verb: GrafVerb; r: Rect; ovWd,ovHt: INTEGER);
;
;  A6 OFFSETS OF PARAMS AFTER LINK:
;
PARAMSIZE       .EQU    10
VERB            .EQU    PARAMSIZE+8-2           ;GRAFVERB
RECT            .EQU    VERB-4                  ;LONG, ADDR OF RECT
OVWD            .EQU    RECT-2                  ;WORD
OVHT            .EQU    OVWD-2                  ;WORD

            LINK    A6,#0                           ;NO LOCALS
            MOVEM.L D7/A3-A4,-(SP)                  ;SAVE REGS
            MOVE.B  VERB(A6),D7                     ;GET VERB
            JSR     CHECKPIC                        ;SET UP A4,A3 AND CHECK PICSAVE
            BLE.S   NOTPIC                          ;BRANCH IF NOT PICSAVE

            MOVE.B  D7,-(SP)                        ;PUSH VERB
            JSR     PutPicVerb                      ;PUT ADDIONAL PARAMS TO THEPIC
;
;  CHECK FOR NEW OVAL SIZE
;
            MOVE.L  PICSAVE(A3),A0                  ;GET PICSAVE HANDLE
            MOVE.L  (A0),A0                         ;DE-REFERENCE PICSAVE
            MOVE.L  OVHT(A6),D0                     ;GET OVWD AND OVHT
            CMP.L   PICOVSIZE(A0),D0                ;SAME AS CURRENT OVAL SIZE ?
            BEQ.S   OVALOK                          ;YES, CONTINUE
            MOVE.L  D0,PICOVSIZE(A0)                ;NO, UPDATE STATE VARIABLE
            MOVE.L  D0,-(SP)                        ;PUSH OVSIZE FOR PutPicLong CALL
            MOVEQ   #$0B,D0
            JSR     DPutPicByte                     ;PUT OVSIZE OPCODE
            JSR     PutPicLong                      ;PUT NEW OVAL SIZE DATA

OVALOK  MOVEQ   #$40,D0                         ;PUT RRECT NOUN IN HI NIBBLE
            ADD     D7,D0                           ;PUT VERB IN LO NIBBLE
            MOVE.B  D0,-(SP)                        ;PUSH OPCODE
            MOVE.L  RECT(A6),-(SP)                  ;PUSH ADDR OF RECT
            JSR     PutPicRect                      ;PUT OPCODE AND RECTANGLE

NOTPIC  MOVE.L  RECT(A6),-(SP)                  ;PUSH ADDR OF RECT
            CLR.B   -(SP)                           ;PUSH HOLLOW = FALSE
            TST.B   D7                              ;IS VERB FRAME ?
            BNE.S   DOIT                            ;NO, CONTINUE
            TST.L   RGNSAVE(A3)                     ;YES, IS RGNSAVE TRUE ?
            BEQ.S   NOTRGN                          ;NO, CONTINUE

            MOVE.L  RECT(A6),-(SP)                  ;YES, PUSH ADDR OF RECT
            MOVE.L  OVHT(A6),-(SP)                  ;PUSH OVWD, OVHT
            MOVE.L  RGNBUF(A4),-(SP)                ;PUSH RGNBUF
            PEA     RGNINDEX(A4)                    ;PUSH VAR RGNINDEX
            PEA     RGNMAX(A4)                      ;PUSH VAR RGNMAX
            JSR     PutOval                         ;ADD AN OVAL TO THERGN

NOTRGN  MOVE.B  #1,(SP)                         ;REPLACE, PUSH HOLLOW = TRUE
DOIT    MOVE.L  OVHT(A6),-(SP)                  ;PUSH OVWD,OVHT
            JSR     PushVerb                        ;PUSH MODE AND PATTERN
            CLR     -(SP)                           ;PUSH STARTANGLE = 0
            MOVE    #360,-(SP)                      ;PUSH ARCANGLE = 360

;  DrawArc(r,hollow,ovWd,ovHt,mode,pat,startAng,arcAng);

            JSR     DrawArc

            MOVEM.L (SP)+,D7/A3-A4                  ;RESTORE REGS
            UNLINK  PARAMSIZE,'STDRRECT'



            .PROC FrameRoundRect,3
            .DEF  CallRRect,PaintRoundRect,EraseRoundRect
            .DEF  InvertRoundRect,FillRoundRect
            .REF  StdRRect
;--------------------------------------------------------
;
;  PROCEDURE FrameRoundRect(* r: Rect; ovWd,ovHt: INTEGER *);
;
            MOVEQ   #FRAME,D0                       ;VERB = FRAME
            BRA.S   CallRRect                       ;SHARE COMMON CODE


;--------------------------------------------------------
;
;  PROCEDURE PaintRoundRect(* r: Rect; ovWd,ovHt: INTEGER *);
;
PaintRoundRect
            MOVEQ   #PAINT,D0                       ;VERB = PAINT
            BRA.S   CallRRect                       ;SHARE COMMON CODE


;--------------------------------------------------------
;
;  PROCEDURE EraseRoundRect(* r: Rect; ovWd,ovHt: INTEGER *);
;
EraseRoundRect
            MOVEQ   #ERASE,D0                       ;VERB = ERASE
            BRA.S   CallRRect                       ;SHARE COMMON CODE


;--------------------------------------------------------
;
;  PROCEDURE InvertRoundRect(* r: Rect; ovWd,ovHt: INTEGER *);
;
InvertRoundRect
            MOVEQ   #INVERT,D0                      ;VERB = INVERT
            BRA.S   CallRRect                       ;SHARE COMMON CODE


;--------------------------------------------------------
;
;  PROCEDURE FillRoundRect(r: Rect; ovWd,ovHt: INTEGER; pat: Pattern);
;
FillRoundRect
            MOVE.L  (SP)+,A0                        ;POP RETURN ADDR
            MOVE.L  (SP)+,A1                        ;POP ADDR OF PATTERN
            MOVE.L  A0,-(SP)                        ;PUT RETURN ADDR BACK
            MOVE.L  GRAFGLOBALS(A5),A0              ;POINT TO LISAGRAF GLOBALS
            MOVE.L  THEPORT(A0),A0                  ;GET CURRENT GRAFPORT
            LEA     FILLPAT(A0),A0                  ;POINT TO FILLPAT
            MOVE.L  (A1)+,(A0)+                     ;COPY PAT INTO FILLPAT
            MOVE.L  (A1)+,(A0)+                     ;ALL EIGHT BYTES
            MOVEQ   #FILL,D0                        ;VERB = FILL
            BRA.S   CallRRect                       ;SHARE COMMON CODE



;---------------------------------------------------------------
;
;  PROCEDURE CallRRect(r: Rect; ovWd,ovHt: INTEGER);
;
;  code shared by FrameRoundRect, PaintRoundRect, EraseRoundRect,
;                 InvertRoundRect, and FillRoundRect.
;  enter with verb in D0.
;
CallRRect
            MOVE.L  (SP)+,A0                        ;POP RETURN ADDR
            MOVE.L  (SP)+,D1                        ;POP ovWd and ovHt
            MOVE.L  (SP)+,A1                        ;POP ADDR OF RECT
            MOVE.B  D0,-(SP)                        ;PUSH VERB
            MOVE.L  A1,-(SP)                        ;PUSH ADDR OF RECT
            MOVE.L  D1,-(SP)                        ;PUSH ovWd and ovHt
            MOVE.L  A0,-(SP)                        ;RESTORE RETURN ADDR
            MOVE.L  GRAFGLOBALS(A5),A0              ;POINT TO LISAGRAF GLOBALS
            MOVE.L  THEPORT(A0),A0                  ;GET CURRENT GRAFPORT
            MOVE.L  GRAFPROCS(A0),D0                ;IS GRAFPROCS NIL ?
            LEA     STDRRECT,A0
            BEQ.S   USESTD                          ;YES, USE STD PROC
            MOVE.L  D0,A0
            MOVE.L  RRECTPROC(A0),A0                ;NO, GET PROC PTR
USESTD  JMP     (A0)                            ;GO TO IT





        .END

TL;DR: Programmers (and processor architects) usually write with some intent in mind, and the resulting work can be measured against how closely it matches that intent. Once the code escapes into the wild, it can be endlessly repurposed, and the original intents of the authors gradually fade away. In this critique I'll be focusing on two cases where the meaning of repurposed code depends entirely on its externalities: the text of the code becomes divorced from its meaning; the execution of the code is only needed to trigger the external effects. Calling the process "misreading code" doesn't quite capture the sense of mischief involved, but it's close.

The Story of Mel

Eric S. Raymond continues to maintain the collection of hacker lore known as the Jargon File. It's origins go back to 1975, and along with hundreds of definitions of programmer slang of that era it also contains a few longer pieces that distill that culture. The Story of Mel (Ed Nather, 1983) describes the oldest description of code misreading I know of--there are certainly older ones out there--and manages to do so in (unintentional) free verse. It begins:

A recent article devoted to the macho side of programming
made the bald and unvarnished statement:

Real Programmers write in FORTRAN.

Maybe they do now,
in this decadent era of
Lite beer, hand calculators, and “user-friendly” software
but back in the Good Old Days,
when the term “software” sounded funny
and Real Computers were made out of drums and vacuum tubes,
Real Programmers wrote in machine code.
Not FORTRAN. Not RATFOR. Not, even, assembly language.
Machine Code.
Raw, unadorned, inscrutable hexadecimal numbers.
Directly.

The text goes on to describe Mel, a Real Programmer:

Mel never wrote time-delay loops, either,
even when the balky Flexowriter
required a delay between output characters to work right.
He just located instructions on the drum
so each successive one was just past the read head
when it was needed;
the drum had to execute another complete revolution
to find the next instruction.
He coined an unforgettable term for this procedure.
Although “optimum” is an absolute term,
like “unique”, it became common verbal practice
to make it relative:
“not quite optimum” or “less optimum”
or “not very optimum”.
Mel called the maximum time-delay locations
the “most pessimum”.

That's a fun hacker story, but it gains a bit more meaning from a CCS perspective. The drum manufacturer didn't intend for their equipment to be used as an impromptu delay loop. Looking at the text of Mel's code would have revealed instructions carefully splattered across the entire drum, but nothing in the documentation of those instructions would have revealed why that would have been useful. It's only after the externalities are accounted for that the code (and its layout) is revealed as an instance of genius. We're not quite to the point where the code is only triggering externalities; for that, we turn to FIRESTARTER. But first, a quick note each about processor architecture and vector instructions.

A very brief primer on power and processor architecture

Here's what you need to know about the recent evolution of processor architecture. Keeping bits on or off requires very little energy. Switching back and forth takes substantially more energy and generates a lot more heat. Increasing the clock frequency of the processor makes the problem worse, as does increasing the number of bits. Vector instructions use lots of bits (up to 512 per register compared with the usual 32 or 64), and each additional core has its own set of vector registers. Doing lots of vector arithmetic a the highest clock frequency will destroy the processor in a handful of milliseconds. Intel processors (and a few others) monitor how much power is being used and how much heat is being generated. As the processor's limit is reached, the firmware will slow down the processor. As electrical and thermal headroom is restored, the firmware speeds the processor back up. This dithering of clock speeds can happen dozens of times per second and is effectively nondeterministic.

Meet a vector instruction

Say hello to vfmadd231pd, a fused multiply-add vector instruction that, according to Volume 2 of Intel's software development manual, will allow the programmer to:

[m]ultiply packed double-precision floating-point values from [the register] xmm2 and xmm3/mem, add to xmm1 and put result in xmm1 (page 5-120)

From a CCS perspective, we can now say something about a bit of actual code, say....

vfmadd231pd %%zmm5, %%zmm0, %%zmm4

There's even a Wikipedia page devoted to this class of instructions (of course there is), where we learn that fused-multiply-accumulate instructions are useful for speeding up matrix multiplication, neural networks, blah blah blah. In isolation, that's about as far as we can go. So let's look at a bit of context.

FIRESTARTER

Here's a sliver of the hand-crafted assembly that comprises FIRESTARTER, a processor stress test created by another Real Programmer, Daniel Hackenberg at TU-Dresden. The original code is written in Python, which generates C with inline assembly code (as there's no way of convincing a compiler that any pure-C code should result in this). If you're not familar with assembly, no worries---just unfocus your eyes and look for patterns. The more familiar you are with assembly, the stranger this code appears: it looks very much like busywork. The following code begins at line 587 of avx512_functions.c.

        ".align 64;"     /* alignment in bytes */
        "_work_loop_skl_xeonep_avx512_1t:"
        /****************************************************************************************************
         decode 0                                 decode 1                                 decode 2             decode 3 */
        "vmovapd %%zmm3, 64(%%r9);                vfmadd231pd %%zmm4, %%zmm0, %%zmm3;      shl $1, %%edi;       add %%r14, %%r9;    " // RAM store
        "vfmadd231pd %%zmm5, %%zmm0, %%zmm4;      vfmadd231pd %%zmm6, %%zmm1, %%zmm26;     shl $1, %%esi;       xor %%rdi, %%r13;   " // REG ops only
        "vfmadd231pd %%zmm6, %%zmm0, %%zmm5;      vbroadcastsd 64(%%rbx), %%zmm5;          shl $1, %%edx;       add %%r14, %%rbx;   " // L1 packed single load
        "vfmadd231pd %%zmm7, %%zmm0, %%zmm6;      vfmadd231pd %%zmm8, %%zmm1, %%zmm27;     shr $1, %%edi;       xor %%rdx, %%r13;   " // REG ops only
        "vfmadd231pd %%zmm8, %%zmm0, %%zmm7;      vfmadd231pd 64(%%rbx), %%zmm1, %%zmm7;   shr $1, %%esi;       add %%r14, %%rbx;   " // L1 load
        "vfmadd231pd %%zmm9, %%zmm0, %%zmm8;      vbroadcastsd 64(%%rbx), %%zmm8;          shr $1, %%edx;       add %%r14, %%rbx;   " // L1 packed single load
        "vfmadd231pd %%zmm10, %%zmm0, %%zmm9;     vfmadd231pd %%zmm11, %%zmm1, %%zmm28;    shl $1, %%edi;       xor %%rdx, %%r13;   " // REG ops only
        "vfmadd231pd %%zmm11, %%zmm0, %%zmm10;    vfmadd231pd 64(%%rcx), %%zmm1, %%zmm10;  shl $1, %%esi;       add %%r14, %%rcx;   " // L2 load
        "vfmadd231pd %%zmm12, %%zmm0, %%zmm11;    vfmadd231pd %%zmm13, %%zmm1, %%zmm29;    shl $1, %%edx;       xor %%rsi, %%r13;   " // REG ops only
        "vfmadd231pd %%zmm13, %%zmm0, %%zmm12;    vbroadcastsd 64(%%rbx), %%zmm12;         shr $1, %%edi; 

If you're a processor architect, what jumps out is how busy this processor is. All four instruction decoders are in use, none of the instructions are conflicting with each other (meaning there are no stalls why the processor waits for results to complete or arrive), and.... it's all nonsense.

We're used to thinking of code in terms of symbolic language: each variable and function is a symbol (representation, model, approximation, whatever term you like to use) of some other thing or action. In the code above, FIRESTARTER has removed the symbolic meaning from code. The instructions are being used exclusively to turn actual bits on and off as fast as possible, thus maximizing power and thermal load. The actual mathematical results are overwritten and recalculated again and again---they don't have any meaning as math, they are just a vehicle for flipping bits.

(In terms of speech acts, FIRESTARTER performs a stream of phonetic and phatic acts (noises and words, respectively) which result in a perlocutionary act (the processor heats up) without reaching an illucutionary act (saying something understandable). I'm far from an expert, though, so I'd be happy to hear other opinions.)

Misreading code

What Hackenberg has accomplished is a deliberate, careful misreading of code (more specifically, the instruction set architecture). The intent of the processor architects at Intel was to create specialized instructions for matrix-related mathematics, but the fact that this intent exists does not preclude additional readings. By taking into account the environment in which the intent was realized, Hackeberg can misread these instructions in order to control secondary effects like power consumption and heat generation.

This kind of misreading is most common in security programming (Spectre/Meltdown, Rowhammer, Plundervolt). In each case, the externalities of the running code allow for privilege escalation.

Misreading FIRESTARTER

So far I've described FIRESTARTER as a program that maximizes the power and thermal response of a processor. That was certainly the intent of the authors. Part of the information it reports is how many iterations of its main loop have executed. These are relatively small loops, so the count tends to be quite large. Here is an example of the output from running on my i9-9900K workstation at home. (Note that FIRESTARTER isn't optimized for this processor.)

My machine starts off at 28C with the water pump fans off. Within a couple second after starting the program, the processor temperature has peaked at 99C and the pump fans are spinning up. (The clock frequency will be dropping here.) One those fans are up to speed the processor stays at a reasonable 65C until the run completes. Here's a portion of what FIRESTARTER reports.

performance report:

Thread 0: 118513178 iterations, tsc_delta: 216052936842
Thread 1: 117377514 iterations, tsc_delta: 215995301932
Thread 2: 118972471 iterations, tsc_delta: 215995301370
Thread 3: 116601636 iterations, tsc_delta: 215995301040
Thread 4: 117583482 iterations, tsc_delta: 215995300430
Thread 5: 118341824 iterations, tsc_delta: 215995300118
Thread 6: 116436094 iterations, tsc_delta: 215995298734
Thread 7: 116491650 iterations, tsc_delta: 215995298446
Thread 8: 120026957 iterations, tsc_delta: 215995299742
Thread 9: 119539717 iterations, tsc_delta: 215995297710
Thread 10: 118192628 iterations, tsc_delta: 215995296440
Thread 11: 116883387 iterations, tsc_delta: 215995296062
Thread 12: 117503542 iterations, tsc_delta: 215995294898
Thread 13: 117667925 iterations, tsc_delta: 215995294150
Thread 14: 119323114 iterations, tsc_delta: 215995293560
Thread 15: 116124503 iterations, tsc_delta: 215995291304

total iterations: 1885579622
runtime: 60.02 seconds (216052936842 cycles)

estimated floating point performance: 233.73 GFLOPS
estimated memory bandwidth*: 20.11 GB/s

* this estimate is highly unreliable if --function is used in order to select
  a function that is not optimized for your architecture, or if FIRESTARTER is
  executed on an unsupported architecture!

Note that the Time Stamp Counter difference (aka tsc_delta) is accurate well within 0.1%; Linux knows how to start and stop execution in the time requested (here, 60 seconds).

But also note that the number of iterations varies quite a bit more than that from thread to thread, from a max of 120026957 to a min of 116124503 iterations completed.

What happens if I run FIRESTARTER 350 times? There is a fair amount of run-to-run variation, but it occurs within a band.

What happens if I run FIRESTARTER 350 on 4,200 ostensibly identical processors (the Quartz supercomputer at LLNL)?

Recall that I mentioned the clock frequency (and thus the number of iterations) depends on the thermal and power load, and that makes deterministic performance more or less impossible. It turns out that the major source of that variation is the variation within the silicon of individual processors. More efficient processors use less power to push bits down their wires, so they can run faster without getting as hot. Less-efficient processors heat up more when running slowly and often can't reach theoretical maximum frequencies at all.

What does that look like? Rather than show you all 4,200 processors, here's the best, worst and median one out of the bunch.

Each box-and-whisker plot shows run-to-run variation (thanks, Linux). There are two hyperthreads per core; there is both core-to-core and hyperthread-to-hyperthread variation (hyperthread 0 is consistently a bit worse than hyperthread 1, and core 12 is consistently better than core 13).

But the processor-to-processor variation dominates. There are the same model and stepping, yet there's an easy 10% difference between the median of the best and the median of the worst processor. (This is known as the "silicon lottery.")

Ok, so what?

Using a bit of undergrad statistics (not shown here), you could run FIRESTARTER for a minute on a random processor and, despite all the variation going on, I'd be able to identify which processor you chose.

In short, I have misread FIRESTARTER to get to the externalities that provide a unique signature for each of 4,200 processors. The FIRESTARTER authors didn't anticipate this. By misreading what they've done, I've gained access to physical information we didn't have before. And that leads to some really gnarly security issues that I'll leave for another time.

Why this matters to CCS

When I was a wee Theater undergrad I had it drilled into my head how the performance consisted of not only actors performing, but the audience and their expectations, the architecture of the theater, subtleties of lighting, sound, costume, gesture, facial expression.... and we have vocabulary and frameworks to discuss how those choices will affect what the audiences takes home. We don't ask whether we can or should misread Shakespeare---that's done as a matter of course. We can do things like stage the first act of Strinberg's Dream Play in the parking lot of an abandoned funeral home in the middle of San Diego where the actors are all mute and their lines have been pre-recorded and are played over loudspeakers (thank you, Sledgehammer Theater). The kind of curiosity and creativity required for that staging feels similar to what's needed for Mel spattering instructions all over his drum memory or Daniel Hackenberg jacking up processor power by executing nonsense fused-multiply-add instructions. We know how to teach those skills to theater students. We're nowhere close to doing that for CS students.

As a computer scientist, I don't have either the vocabulary or frameworks to explain how I go about my misreadings (and I've built my career on them). I would like to give my students and interns an apparatus (or several) that allows them to think about code like their colleagues in the theater department think about performance. I suppose you could say that I want them to read code critically. I'm hoping that CCS can eventually provide that scaffolding.

Questions for Discussion

1. You made it this far? You badass!
2. Where in the above did your eyes begin to glaze over?
3. What are your experiences with deliberate misreading of code?
4. How do you teach your students how to be creative, and how would you apply that to teaching CS students?

Democrats have no Iowa caucus results, blame 'coding issue'
Democrats have no Iowa caucus results, blame ‘coding issue’
Iowa Democrats blame ‘coding issue’ for botched caucus results

The headline comes from a statement from Iowa Democratic Party Chair Troy Price:

“While the app was recording data accurately, it was reporting out only partial data,” Price said. “We have determined that this was due to a coding issue in the reporting system.”

With the caucus "meltdown," coding is once again the center of social conflict. As elections more and more rely on electronic means, black-boxed code (black boxed for security reasons) takes the place of the ballot boxes with their the hanging chads. But the ideal of democracy hinges on notions of transparency, accountability, and the mythical "free and fair elections." Code becomes a surrogate or proxy for the unseen machinations or in this case, the failures of political machinery.

Coding, in this case takes some of the pressure off of humans. Take this line:

Des Moines County Democratic Chair Tom Courtney said the new app created “a mess.”

Election software epitomizes that critical code that affects so many vital facets of our lives. Both @DavidBerry and I have written about open source voting software. But again, the code for this software is not in the public eye, presumably to avoid hacking. As NPR reporter Miles Parks commented before the election:

It's one thing to introduce a new piece of election technology without really any practice beforehand, and then it's another thing to introduce that piece of election technology without giving any security details about it. We know very little about the specifics of this app. We don't know who developed it or who wrote the code. We don't know what sorts of security tests have been performed on it. These are the two basic questions that any security expert would ask when confronting a new system. And the Democratic Party says, basically, they're not going to provide any of this information because they're scared it would help hackers. But experts actually say that that secrecy doesn't help against hacking at all.

I look forward when the Freedom of Information Act makes the code for the Iowa App available for investigation, assuming that applies.

Meanwhile, in Iowa, they are reportedly back to tallying votes on paper.

What role does "coding" play in our discussion of this debacle? How does this news story speak to public perceptions of coding?

Abstraction, disembodiment, and the environment

Below is a snippet of code showing how to set up a small single-input neural network that performs binary classification in Keras (a popular deep learning framework in Python):

# For a single-input model with 2 classes (binary classification):
model = Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# Generate dummy data
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))

# Train the model, iterating on the data in batches of 32 samples
model.fit(data, labels, epochs=10, batch_size=32)

This example code comes from a guide found in the Keras docs. The chunk of code under the first comment creates a sequential model with two Dense layers and compiles it. The chunk of code under the second comment generates dummy training data and labels. Finally, the last line of code trains the model by passing in training data and labels into a function called “fit”.

I want to focus specifically on the seemingly simple “fit” function. Many other machine learning frameworks are similar in that after setting up the model architecture and training data, all you have to do is call the “fit” method to actually train the model and the framework will take care of the rest.

On one hand, this abstraction is really helpful. You don’t need to backpropagate millions of weights by hand. You don’t even need to know what backpropagation means. As long as you define a model architecture and feed in some training data and labels, you can train a model. This lowers the barrier of entry to training a neural network.

But on the other hand, we pay an environmental price for this abstraction that we don’t immediately internalize. The sample I posted here is a toy example. But imagine if we had a much larger network like BERT, which is a state-of-the-art neural network developed by Google and used for a variety of NLP (natural language processing) tasks. The smaller model (BERT base) has 110 million total parameters and the larger model (BERT large) has 340 million. A paper published last year by the University of Massachusetts Amherst detailing the energy usage of deep learning in NLP shows that “[...] training BERT on GPU is roughly equivalent to a trans-American flight” (see Table 3 on page 4 of the paper). The amount of computational resources needed to train BERT is enormous: “NVIDIA reports that they can train a BERT model in 3.3 days (79.2 hours) using 4 DGX-2H servers, totaling 64 Tesla V100 GPUs”.

There are even more abstractions that make training models easier but also further distances us from its actual physical impacts. Don’t own 64 GPUs? No problem. You can pay AWS (Amazon Web Services) or Google Cloud to use their computing resources. It is common practice now to train models “in the cloud”. Now there really is no immediate physical indicator of how much computing resources you’re using. It’s all just ~ in the cloud ~

Abstraction is a holy tenet of software engineering. In my computer science classes, I was taught to hide all unnecessary complexities behind clearly defined, easy-to-use APIs. I never considered that a side effect of all this abstraction was a sense of disembodiment. The idea that there are physical limitations is as obvious as saying “water is wet” and yet, something I rarely think about as a software engineer. I just always assume that I will have the computing resources I need.

Reembody and Reimagine

Grappling with the disembodiment of abstraction and virtual space reminds me of a beautiful essay published by the MIT Press called “Making Kin with the Machines” (Disclaimer: this was published as a critique/response to a manifesto Joi Ito wrote while he was still at MIT. However, he is not an author of the essay). This paragraph sums up what I hope to learn and discuss through the lens of Indigenous programming:

“One of the challenges for Indigenous epistemology in the age of the virtual is to understand how the archipelago of websites, social media platforms, shared virtual environments, corporate data stores, multiplayer video games, smart devices, and intelligent machines that compose cyberspace is situated within, throughout and/or alongside the terrestrial spaces Indigenous peoples claim as their territory. In other words, how do we as Indigenous people reconcile the fully embodied experience of being on the land with the generally disembodied experience of virtual spaces? How do we come to understand this new territory, knit it into our existing understanding of our lives lived in real space, and claim it as our own?”

As someone who is currently living on stolen Duwamish lands, I am not the right person to answer these questions. So I would really love to learn from people who are or anyone could better expand upon these topics:
1. [From the paragraph above]: How do we as Indigenous people reconcile the fully embodied experience of being on the land with the generally disembodied experience of virtual spaces? How do we come to understand this new territory, knit it into our existing understanding of our lives lived in real space, and claim it as our own?
2. We are currently in a climate crisis that is only going to get worse. Not only is there an environmental impact from machine learning, but also huge impacts from data storage, networks, and the mining of minerals for devices to name a few. In the essay, the authors (who are Indigenous peoples themselves) state: “We undertake this project not to “diversify” the conversation. We do it because we believe that Indigenous epistemologies are much better at respectfully accommodating the non-human.” And I wholly agree. What are different Indigenous lenses we can look through to incorporate technology respectfully with the environment? What about other lenses?

First launched in 2001, the Political Compass quiz has made an indelible mark on online political discussion, popularising a two-axis political spectrum and launching thousands of memes. In the quiz, the participant answers strongly agree, agree, disagree, strongly disagree on a number of questions, each answer having a hidden point rank which moves them up and down two scales of authoritarian/libertarian and left/right. The outcome is a point on a four-quadrant chart.

The trouble with this format is that even if it were possible to word and present the questions in a non-leading way (something the original political compass actively avoids doing), the point values would still necessarily be arbitrary. This can be seen in the code below. As the Political Compass's source is hidden, I have presented one of it's successor quizes instead. This Political Compass of the Revolution has the same structure as its forebear. However rather than trying (and failing) to reflect an ideology for all people, places and times, it focuses purely on specific factions in a specific time and place (namely, the main political groupings in Russia in 1917). In this way it is more informative than the original Political Compass (the specific positions on the chart actually reflect real positions), and it is able to tell you which faction your answers are closest to, and what those factions answers would be.

Here's a relevant section of the code, which shows the questions and the point values for their answers:

 questions: [
      {
        id: 1,
        title: 'Private property is a natural right and a vital economic institution.',
        answersWeight: [16, 8, 0, -8, -16],
        axis: 'x'
      },
      {
        id: 2,
        title: 'The agrarian question can only be resolved through socialization of all land. Land should become the property of the people as a whole and should not be bought and sold!',
        answersWeight: [-32, -16, 0, 16, 32],
        axis: 'x'
      },
      {
        id: 3,
        title: 'I favor swift nationalization of the key sectors of industry.',
        answersWeight: [-14, -7, 0, 7, 14],
        axis: 'x'
      },
      {
        id: 4,
        title: 'A universal shortening of the workday to eight hours is essential.',
        answersWeight: [-14, -7, 0, 7, 14],
        axis: 'x'
      },
      {
        id: 5,
        title: 'The workers must be given control of industrial enterprises.',
        answersWeight: [-14, -7, 0, 7, 14],
        axis: 'x'
      },
      {
        id: 6,
        title: 'Elections should be universal, direct, fair and secret.',
        answersWeight: [6, 3, 0, -3, -6],
        axis: 'y'
      },
      {
        id: 7,
        title: 'The State, as a matter of principle, does not have a right to limit freedom of speech or assembly!',
        answersWeight: [8, 4, 0, -4, -8],
        axis: 'y'
      },
      {
        id: 8,
        title: 'Women should receive rights equal to those of men!',
        answersWeight: [6, 3, 0, -3, -6],
        axis: 'y'
      },
      {
        id: 9,
        title: 'The Church should be separated from the State!',
        answersWeight: [6, 3, 0, -3, -6],
        axis: 'y'
      },
      {
        id: 10,
        title: 'The death penalty is a vital means of punishment during current wartime conditions.',
        answersWeight: [-6, -3, 0, 3, 6],
        axis: 'y'
      },
      {
        id: 11,
        title: 'The war with Germany, Austro-Hungary, Bulgaria and the Ottoman Empire has been going on for three years. This war must be swiftly ended through a democratic peace without annexations or levies!',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 12,
        title: 'It is vital to defend the Revolution, but not to carry out attacks!',
        answersWeight: [-2, -1, 0, 1, 2],
        axis: 'y'
      },
      {
        id: 13,
        title: 'We should honor our responsibilities to our allies. War until a victorious end!',
        answersWeight: [-4, -2, 0, 2, 4],
        axis: 'y'
      },
      {
        id: 14,
        title: 'Democratization of the army is good. There is no need for military insignia, officers should be elected, they must be equal in rights with soldiers.',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 15,
        title: 'Military dictatorship is the best way to get out of the revolutionary crisis.',
        answersWeight: [-6, -3, 0, 3, 6],
        axis: 'y'
      },
      {
        id: 16,
        title: 'I support the Provisional Government!',
        answersWeight: [-4, -2, 0, 2, 4],
        axis: 'y'
      },
      {
        id: 17,
        title: 'The present state of the Revolution demands a lengthy period of agreement between all democratic forces.',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 18,
        title: 'I am for the swift convocation of the Constituent Assembly!',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 19,
        title: 'The Soviets of Worker, Soldier and Peasant Deputies should take over the reigns of state power!',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 20,
        title: 'The city Dumas (legislatures) are the proper mechanism for self-government, we don’t need any other.',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 21,
        title: 'The working class is the driving force of the Revolution.',
        answersWeight: [-14, -7, 0, 7, 14],
        axis: 'x'
      },
      {
        id: 22,
        title: 'The State should be swiftly liquidated and replaced by the people’s self-government.',
        answersWeight: [24, 12, 0, -12, -24],
        axis: 'y'
      },
      {
        id: 23,
        title: 'A federal state structure is the best option for multinational Russia.',
        answersWeight: [8, 4, 0, -4, -8],
        axis: 'y'
      },
      {
        id: 24,
        title: 'Russia should continue to be a major power, retaining its continental and overseas colonies, ruled from the center.',
        answersWeight: [-6, -3, 0, 3, 6],
        axis: 'y'
      },
      {
        id: 25,
        title: 'A multiparty system is capable of serving to stabilize democratic power.',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 26,
        title: 'Russia’s political system should develop in the direction of parliamentarianism.',
        answersWeight: [4, 2, 0, -2, -4],
        axis: 'y'
      },
      {
        id: 27,
        title: 'Our end goal is socialism!',
        answersWeight: [-14, -7, 0, 7, 14],
        axis: 'x'
      },
    ],

There's presumably some rationale why strongly agreeing to question 23 should move you 8 points along the Y axis while strongly agreeing to 25 moves you half as much. Even if we allow that there is an art to judging the comparative ideological significance of any given opinion, the exact numbers chosen cannot escape being somewhat arbitrary.

Note that the purpose of the quiz is achieved without reference to the axis position: at the end of the quiz it judges how close your answers are to the answers of other historical actors, and that can be done just by comparing your answer with theirs: the exact point values of these answers don't matter. In this way, this version of the political compass points the way towards more meaningful ideology tests.

Upon the occasion of CCSWG20, artist Erik Loyer has shared the code for Ruben & Lullaby, a wonderful iOS work in which you play (as in playing a musical instrument) a conversation between two fighting lovers. You can make it worse by aggravating them or try to smooth things out, as you interact to calm them down (via rubbing the screen) or irritate them (by shaking it). The piece also features a "dynamic score," which is also affected by user interaction.

Erik has pointed us in some potential areas of interest:
Input is handled in EAGLView.m — both accelerometer (tilt to cut, shake to anger) and touch (tap to change eye position, stroke to calm).

The logic behind the story mechanics, shot transitions, and the dynamic score is all contained in StoryManager.m — I'm interested in exploring these as potential constraints on live performance by actors and musicians.

The XML file rl_data.xml contains data describing each character view, as well as a script that serves as a kind of superstructure for the experience.

In Localizable.strings you can find the vestiges of an abandoned attempt to make the story mechanics easier to grasp through text.

Here's a demo of the app.

Let's explore.

Language: Python

Authors: n/a

Years: 1990-

Works cited: Frings et al., Massively Parallel Loading, ICS 2013. (pdf)

TL;DR Extracting meaning from code requires understanding (modeling) what is left unsaid.

The code I'll be critiquing is an empty python script, perhaps the computer science equivalent of 4'33''.

Creating the code is trivial on any *nix machine:
$ python --version
Python 2.7.17
$ touch nothing.py
$ ls -l
total 0
-rw-r--r-- 1 rountree rountree 0 Jan 18 14:06 nothing.py
$

touch creates and empty file with the specified filename, and ls -l shows the size of the file is indeed 0. Running this code is about as exciting as you might expect.

$ python ./nothing.py
$

The temptation is to think that nothing happened: we didn't ask Python to do anything, and it complied with alacrity. In most computing environments, that summary is a perfectly serviceable abstraction of what happened. But it is an abstraction, and interesting things happen when ground truth starts diverging too far from our abstraction of it.

Let's take a closer look.

$ strace python ./nothing.py 
execve("/usr/bin/python", ["python", "./nothing.py"], 0x7ffc76d71d08 /* 56 vars */) = 0
brk(NULL)                               = 0x55a94fcaf000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
....

strace captures all of the calls that the Python interpreter makes into the linux kernel (e.g., brk), lists the parameters for each of those calls (NULL) and the value that's returned (0x55a94fcaf000), possibly with an explanation if there's an error (-1 ENOENT (No such file or directory)). What each of those individual lines mean to a systems programmer is beyond the scope of this critique. The aggregate numbers are more interesting.

$ strace python ./nothing.py 2>&1 | wc -l
746

The 2>&1 is a bit of magic to put output routed to stderr (which strace uses) to stdout (which the rest of the tools expect). The pipe | routes the stdout of the prior command to the stdin of the next command. wc -l simply counts how many lines there are in stdin and outputs that number.

Roughly speaking, in order to run nothing.py, our Python interpreter made 746-ish calls into the linux kernel.

Which seems a little excessive.

Through the magic of bash one-liners we can get a sense of what's going on.

$ strace python ./nothing.py 2>&1 | cut -d "(" -f 1 | sort | uniq -c | sort -rn | head
234 openat
 99 fstat
 98 read
 87 stat
 68 rt_sigaction
 66 close
 25 mmap
 14 mprotect
  8 brk
  8 access
 [only the top 10 shown]

That's 234 distinct attempts to open files. On a laptop, that happens so fast as to be unnoticeable. On a supercomputer, however....

KULL [15] is a large multi-physics application developed at LLNL. When it was first run on Dawn, an IBM BlueGene/P system, its start-up exposed serious scaling challenges and significantly disrupted the entire computing center. The KULL executable was dynamically linked to about one thousand shared libraries, most of them staged in an NFS file system to ease maintenance. Loading these libraries during program start-up scaled extremely poorly. The time from job launch to the initial invocation of KULL’s main function, for instance, took about one hour at 2,048 MPI processes and ten hours at 16,384 processes. Further, during start-up, the NFS server was overwhelmed with load requests from KULL, and other users and jobs were unable to connect to the NFS while KULL start-up continued. [Frings 2013, emphasis in original]

The problem was that both the python libraries and those used by KULL itself were all located on single filesystem that the compute nodes accessed over the network. 16,384 processes starting up and simultaneously demanding 1,000+ libraries each utterly overwhelmed the filesystem. The fix was clever enough to be published (distribute libraries via a tree network, see the paper for details), but doesn't inform this critique.

And with that background in place we can now do a code critique.

So what does this code --- or lack of code --- actually mean?

Trawling through the Python source code to understand its initialization process would be tedious and error-prone. It's much faster to run Python under instrumentation (in this case, strace) and watch what it does. The empty script guaranteed that all the activity we'd be seeing would be coming from Python, not our code.

Ok, that's what you did, but you still haven't told me what it means.

Three points.

First, the text of code is an unreliable guide to its performance. There may be a strong guarantee as to correct behavior, but there are rarely any guarantees about how that behavior will be accomplished. The behavior of code is generally more important than its text, but that behavior is contingent upon everything from the rest of the computing ecosystem to the society in which the code operates.

Second, there might be a temptation to claim that if we had enough information about the system we could have perfect knowledge of the code's behavior. We're never going to be able to get that much information out of nontrivial systems, so we're left with using simplified models. As Box remarked: "All models are wrong, but some are useful." Becoming skilled in the art of system design, programming or code critiquing requires figuring out where your model can simplify without doing too much violence to your results.

Third, CCS understandably puts a great deal of emphasis on text. This example is a corner case of how that approach can break down. Unfortunately, learning how to do code instrumentation is at least as difficult as learning how to code in the first place, and there's definitely a lack of friendly guides to performance analysis. One way around the problem might be more collaboration.

Questions for discussion:

A. What examples of implied, misleading or ironic code have you come across in your own work?

B. What tools do you use to compare code-as-text versus code-as-performance?

C. How should CCS handle implied, misleading or ironic code?

Notes: I generated the example using Python 2.7.17 running on a Linux 5.0.0-37 kernel provided by Ubuntu 18.04.3 (Bionic Beaver). Running Python 3.6.9 on that same machine only generates 67 calls to openat.

OSX users can substitute dtruss for strace, but doing so requires running as root and disabling system integrity protection.

Overview:

In machine learning with neural networks, the practice of transfer learning uses one network trained for one task on another related but different task, without fully retraining the original network. This approach works in practice and it seems to mirror how humans use previous experience to learn new tasks. The learning of the new task in ML could then be thought of as “emergent” behavior, as the network classifies new input data under new categories.

There are lots of possibilities for philosophical reflection on this emergent behavior, although, transfer learning can also more clearly demonstrate how machine learning can be biased in potentially dangerous or unjust ways. In fact, in some of the early papers on multi-task and transfer learning, learning outcomes improve when ML learns with “bias”, a fact wholly accepted by the authors (see for example, R. Caruana, “Multitask Learning”. Machine Learning, vol. 28, 1997, p. 44).

That some bias is necessary in learning or knowledge production is an insight that philosophers have also come to understand through science studies and much contemporary thought. But this does not remove the potential danger or injustice. Consider an example of a transfer learning of possibility in multilingual language learning. Similarly, consider a transfer learning of injustice in facial recognition. These are possibilities and injustices that are present in neural networks in general. The code I would like to consider more fully dramatizes this bias however.

The code to consider comes from an ML tutorial on the TensorFlow.org website. TensorFlow is a higher level programming framework for neural network-based ML. Interestingly, this tutorial uses TensorFlow Hub, a repository of reusable, pre-trained models. In some ways, this repository provides a central gesture of transfer learning made into a new software platform.

To demonstrate the disconnect and potential bias between the classifying task of the originally trained network and the transfer network applied to a new, related task, consider first of all that the pre-trained model from this repository of models is loaded and configured with just 3 lines of code:

classifier_url ="https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2" #@param {type:"string"}

IMAGE_SHAPE = (224, 224)

classifier = tf.keras.Sequential([
    hub.KerasLayer(classifier_url, input_shape=IMAGE_SHAPE+(3,))
])

Secondly, in the beginning of the tutorial, a photograph of Grace Hopper, the famous woman in technology, is fed in as test data after establishing the transfer-learned network. Bias of the original network is shown by the fact that the new network classifies the image as “military uniform” (That Dr. Hopper is wearing) rather than “Grace Hopper” or “Important early computer scientist”, etc.

Following through the tutorial, a pre-trained network is loaded for a second example and its network weights are explicitly set not to be trained further (the whole point of transfer learning is to not have to retrain them):

feature_extractor_layer.trainable = False

Only, the final layer of the network is removed and a classifying layer (a “classification head”) for recognizing flower species is configured as the penultimate set of nodes.

model = tf.keras.Sequential([
  feature_extractor_layer,
  layers.Dense(image_data.num_classes, activation='softmax')
])

Until in the tutorial the network is modified further, adding the classification head, the flower detection is not as “accurate”. So in this case, the neural network is potentially unjust until accurate. That the recognition is first inaccurate in this case shows the limitations of transfer learning. But after adding the classification head, the network identifies most of the flowers accurately. Herein lies transfer learning’s philosophical possibility, but this possibility has its own limitations.

Questions

How does the TensorFlow Hub model repository both demonstrate an AI of possibility as well as injustice?

Does transfer learning effect a truer “reuse”, much more powerful than traditional reusable software components and libraries?

If ML/AI can be unjust, despite the role of bias in all learning, is this because it is tied to software and legal policy that impinges upon democracy (by excluding some members of a commonwealth)?

Are there limitations to looking at transfer learning as emergent, given that a learning network, in not being a simulacra of a human brain, could nevertheless be a mirror of “Reason” in a way that would be problematic for 20th Century critiques of Enlightenment (i.e. Adorno, Horkheimer et. al.)?

• Author: Leonardo Flores
• Year: 2017/2018
• Link: https://cheapbotsdonequick.com/source/Protestitas
• Language: JavaScript
• Snippet:
  "cacerolazoprotesters" :["?#protesterfaces#??", "?#protesterfaces#??", "Ϙ#protesterfaces#??"],
  "featuredslogans" :["#PRslogans#", "#PRslogans#", "#PRslogans#", "#PRslogans#", "#postrickyslogans#"],
  "rickyslogans" : ["¡\#FUERARICKY", "¡\#RICKYRENUNCIA", "¡RICKY RENUNCIA YA", "¡FUERA RICKY", "¡RICKY VETE YA", "¡RICKY DICTADOR", "¡RICKY CORRUPTO", "¡RICKY RENUNCIA AHORA", "¡\#RICKYRENUNCIAAHORA", "¡\#UNNUEVOPUERTORICO"],
  "rickyslogans2" : ["¡RICKY TE BOTAMOS", "¡RICKY PA' FUERA", "¡RICKY NO VUELVAS", "¡FUERA RICKY", "¡\#UNNUEVOPUERTORICO"],
  "postrickyslogans" : ["¡ESTAMOS PENDIENTES", "¡DEJEN EL POLITIQUEO", "¡NO MAS CORRUPCION", "¡BOTAMOS A RICKY Y LOS PODEMOS BOTAR", "¡\#UNNUEVOPUERTORICO", "¡FUERA PIERLUISI", "¡\#RENUNCIA WANDA"],

Just have a look and analyse this for me please!!

When I was invited to edit a section of the Responsible Communication Style Guide, one of the terms we added to our “Terms to Avoid” list was "master/slave" to describe primary and secondary nodes. In the volume, we suggest using the alternative “primary/replica”; these are terms I continue to use whenever I come across this replication structure.

The web framework Django and the open-source CMS Drupal formally replaced master/slave with primary/replica back in 2014 (Conversation in the Django project and Drupal release notes) Other open-source projects have since then opted for similar alternatives.

The relational database MySQL is among a few open-source projects that have retained “master/slave” terms. In MySQL, master/slave replication refers to configuring a database such that the contents of one database (a “master”) can be automatically copied to others (or “slaves”).

Here are the instructions for configuring the “master” database in a “slave” database:

mysql> CHANGE MASTER TO
    ->     MASTER_HOST='master_host_name',
    ->     MASTER_USER='replication_user_name',
    ->     MASTER_PASSWORD='replication_password',
    ->     MASTER_LOG_FILE='recorded_log_file_name',
    ->     MASTER_LOG_POS=recorded_log_position;

Once configured, one can start the “slave” by running the following:

mysql> START SLAVE;



(Source: "Setting Up Replication Slaves", MySQL Documentation)

From what I've gathered arguments for and against changing the terminology come down to context: one group argues that since these terms do not refer to the legacy of American slavery nor to an oppressive relationship between humans, these terms should not change (See: “On Redis master-slave terminology” by Redis creator Salvatore Sanfilippo). Another group argues that as our understanding of language evolves, so should the terms we use, especially when alternatives may be both inclusive and more accurate (See: “Let’s Stop Saying Master/Slave” by Mike Roberts).

With Django and Drupal, community-driven conversations helped precipitate the terminology change. I’ve searched for examples of community conversations from MySQL users where this has been debated, but have not found any as of yet.

Questions to consider:

• Who should be involved in conversations about updating terminology?
• Developers are already accustomed to changes in language paradigms: new programming languages are created, and newly released versions of established programming languages bring changes to syntax and some terms. How can we make the terminology change process (which is left up to individual projects) similar?
• While many programming languages are written in English, many developers are non-native English speakers and/or live in countries where English is not the dominant language. Do we need to provide cultural context when communicating terminology alternatives? If so, how do we do this in a way that encourages understanding versus resistance?


I welcome your thoughts!

Author: Pacian (Great Britain)
Language: TADS
Year: 2007

I've been thinking a lot about how imperative and function-oriented the input language of interactive fiction seems to be. Why don't we broaden it to the extent that writing whole pieces of an IF text could be user's commands?

IF is concentrated on actions and pragmatics - which is a paradox, since it's a very descriptive literature and utterly descriptive games. I believe IF doesn't have to be narrative and action-based, and the presented code gives us a tool to make the language of user's commands unlimited. In fact, it could level with the output language of descriptions and narrative that might change relations between author and wreader dramatically - or even reverse.

I believe constant addition of new commands makes role a wreader significantly more complex and contribute more correlation between the playing instances. Can readers become true co-authors of textual adventures?

The code itself:

//A new direction object
forwardDirection: Direction
name = 'forward'
dirProp = &forward
//an integer to sort this direction
//relative to other directions
//we'd give 'backwards' greater than 8000
//for example, so 'forwards' is always listed
//before it
sortingOrder = 8000
;

//the grammar rule for this direction object
//type 'forward' or 'f'
//to try and head in this direction
//(more synonyms preferable)
grammar directionName: 'forward' | 'f' : DirectionProd
dir = forwardDirection
;

/*
* According to actions.t:
*
* "To make it more convenient to use
* directional travel actions as
* synthesized commands, [we] define a set of
* action classes for the specific
* directions."
*/
DefineAction(Forward, TravelAction)
getDirection = forwardDirection
;

//kill the old 'forward' command.
//The only useful piece of code I found in
//"Relative Direction System for TADS 3" by
//Michael J. Roberts
//(It has been modified)
replace grammar directionName(fore): ' ': DirectionProd ;

Calls for Proposals
Print Guidelines

Digital Humanities Quarterly Special Issue on Minimal Computing
Guest editors: Alex Gil (Columbia University Libraries) and Roopika Risam (Salem State University)

Abstracts due January 30, 2020

Special Issue Description

This special issue of Digital Humanities Quarterly will bring together essays and case studies on the promises and limitations of minimal computing from historical, practical, and theoretical perspectives, as well as within the context of specific research projects and their environments.

Minimal computing can be defined as any form of digital or computational praxis done under some set of significant constraints of hardware, software, education, network capacity, power, agency or other factors. Within the context of digital humanities scholarship, minimal computing refers to such computing practices used for teaching, research, and the construction and maintenance of a hybrid -- digital and analog -- scholarly and cultural record.

Broadly construed, our scope is not limited to digital scholarship within the confines of universities and thus includes work undertaken in galleries, archives (institution and community-based), and libraries, as well as in collaboration with communities. In this issue, we strive for equity in gender and particularly encourage submission by women and gender minorities. We further actively seek to include at least one contribution from each of the following geographical areas: Latin America, Africa, and Asia. We are able to accept submissions in English, French, Portuguese, and Spanish.

Suggested Topics
Topics can include but are not limited to:

• Minimal hardware: aged machines, USBs, arduinos, simple circuits, etc.
• Minimal computation: simple scripts, bash, tranductions, etc.
• Static site generation
• Teaching fundamentals of computing tied to subjects in the humanities and the humanistic social sciences
• Forms of making-do in relation to computation: jugaad, hacktivism, DIY
• Technological disobedience, i.e. using technologies in a way they were not intended
• Marginal forms of knowledge and memory production involving computation
• A critique of minimal or minimalist approaches undertaken by choice, rather than by necessity
• Genealogies of minimalist forms of computation
• Case studies on projects that address a multiplicity of costs (environment, bandwidth, access, maintenance, etc) and needs (publishing, remembrance, resistance, etc) with an overall reduction in complexity
• Implications of minimal computing practices for universities, libraries and archives.

Submission Formats

The special issue will consist of two sections: The first section will be reserved for scholarly arguments grounded in history or well argued theoretical work on minimal computing, and the second section will include case studies in the form of specific projects or deep descriptions of environments that pose particular challenges or constraints for digital scholarship and strategic responses to them that incorporate minimal computing practices.

In the first section, we welcome historical perspectives on minimal computing that place contemporary practices in dialogue with multiple documented genealogies; theoretical or strategic pieces that examine socio-technical implications of these practices at scale today; and critical or skeptical voices who are familiar with the implications of minimal computing and the informal discussions and practices that have taken place in the recent past.

For the second section we welcome deep descriptions of projects and environments that include, extend, and complicate minimal computing practices, prompting meditations on difference and imperfect similarity between multiple projects or environments. These case studies should help mainstream audiences understand the granular thinking behind design decisions that respond to specific constraints and challenges.

Submission Details

We ask that you send your abstracts (max. 500 words) to rrisam@salemstate.edu and agil@columbia.edu by January 30, 2020 for a first round of review. Early inquiries are encouraged. We will notify all submitters of the status of their submission in late February. If you are invited to submit a full-length article (~4,000-8,000 words) or a case study (~2500 words), we ask that they be submitted by June 30, 2020.

// Approach 1
function anagram(text) {
  var a = text.split("");
  for (var i = 0; i < a.length; i += 1) {
    var letter = a[i];
    var j = Math.floor(Math.random() * a.length);
    a[i] = a[j];
    a[j] = letter;
  }
  return a.join("");
}

and

// Approach 2
function anagram(text) {
  return text.split("").sort(function () {return 0.5- Math.random()}).join("");
}

A thing to note about these is that they don't achieve the same thing. I initially posted a demonstration of that here.

Functionality

Firstly, note that both approaches are biased in terms of the distribution of permutations they create.

There's a simple counting argument here as to the bias in the two approaches. (Both might be suitable for a follow-up question during this hypothetical interview.)

For the first approach, we make n swaps, each picking a target from n elements. There are thus n^n potential paths through the algorithm. However, there are n! distinct permutations. Because the former value doesn't divide cleanly by the latter [example: n = 8, n! = 40320, n^n = 16777216, 16777216 isn't evenly divisible by 40320], the argument is that there must be some bias in the outcome - some "anagrams" crop up more frequently than others. (This is evident even when we're producing anagrams of a simple string like "abc", which you can try by hand.)

For the second approach, any analysis of behaviour needs to rely on the fact that the sorting algorithm is likely to have been picked with a runtime of n . log_2 n. [There are multiple ways to implement a sort, but that's a common behaviour. For n=8, a sort may make 8 . (log_2 8) = 24 comparisons.] Each time the sort algorithm makes a comparison, it'll perform one of two operations: swap, or don't swap. Thus, there are 2 ^ (n log_2 n) potential paths through the algorithm - or again, n^n. [For the case n=8, this comes out as 16777216 again.]

However, sorting algorithms try hard to not make comparisons when they "know" what the result would be; thus, this approach produces a much stronger bias in the sampled outcomes. Indeed, some potential anagrams of eight characters don't show up at all during the sample run.

[Assuming the sort function isn't broken, all permutations can turn up - we'd just require far more runs before we expected to see the extreme cases.]

On the question of which of those approaches is "stronger": the first approach produces outputs which are closer to uniform. Additionally, it requires a far smaller change to bring its output to a strictly uniform distribution. The second approach may be "clever", but it's by no means clear that it could be adjusted, should uniformity of output be desired.

If I had to interpret those two samples, I'd say it was much more likely that the second was a reproduction of a trick seen elsewhere, whereas the first seems more likely to be an on-the-spot invention.

The desirability of uniformity of distribution and the problem statement

Why desire a uniform distribution? There's certainly a certain symmetrical draw to it. At the other end of the spectrum, sorting all input characters may suffice - or simply returning the input string. (Where Unicode strings are concerned, "returning the value you've been given" is about the safest thing you can do - see below.)

If the requirement in the problem statement ["An anagram contains all the same characters of the initial string or word in a different order"] is a strong one, then the last option doesn't work - and both of the suggested approaches also have a flaw. However, under those circumstances, we should note that there are inputs where no algorithm can meet a strict interpretation of that requirement. [Examples: any single-character string, or "AAA", etc.]

There may be other, less specific versions of "better," when picking a distribution - for instance, finding letter-orderings which produce more challenging anagrams for a human solver, or ones that embed wry phrases.

Pedantry to one side, however...

Broader observation

In typical i18n-blindness, all approaches here don't deal correctly with combining characters and other tricky Unicode features.

I'd also observe that there's a western bias - perhaps even an Anglophone one - to the problem statement. I'm not sure that the notion of an anagram even applies across all the languages that Unicode covers. But the problem there can be found closer to home: if you asked Herr Gauß how many anagrams his surname generated, the answer probably wouldn't be 24. The Unicode consortium offers some partial approaches to dealing with this, but they are by no means comprehensive (and a desire for a comprehensive approach is misplaced, usually arising from an underestimation of how complex the problem space is). Software that deals with human text is notoriously hard to get even close to correct in a cross-cultural fashion. (cf. the question of "how should software handle names?" which has been the subject of a number of writeups.)

In Colaboratory, code readers can share python code in a Google Doc-like setting. The code in those docs can be compiled, altered, and run.

I'd like to use this thread as a place to discuss Colaboratory/Jupyter Notebooks as a venue or workspace for Critical Code Studies.

Taroko Gorge is here for our collective annotation.

For another example, I offer my own interactive fiction Flight of the CodeMonkeys as another example of using Colaboratory/Jupyter Notebooks. In that story, the reader plays by interacting with the code.

I could also imagine using Colaboratory/Jupyter Notebooks to teach lessons in CCS, inviting students to interact with, annotate, and alter code in this shared environment?

What do you think about the possibilities for this tool? I invite you also to try experiments and share them here.

Here are a few tips to help you create great discussions:

This forum has a text editor that uses markdown. Go here for a guide to formatting in markdown.

Proofread. Spelling mistakes, typos, and bad grammar will distract readers from the point you’re trying to make. Vanilla automatically saves drafts as you type. If you’re writing a long post, save it as a draft and come back to it after a few minutes or as long as it takes your brain to forget what you had written.

Use minimal formatting. Overly formatted posts can also distract from the message and it encourages others to do likewise and you end up with a hard to read thread.

Put your post in the right category. The right category can be the one that has a relevant category name or it can be a category where this kind of post is often made.

Use tags. Tags are helpful for others to find keyword related posts. It also helps the site admins get a sense for what topics are popular.

Add an image. Images add visual interest and make your post look great when shared to social networks. You can embed an image using the button bar or you can upload one from your desktop or phone.

Mention others. Credit other members if you are building off their previous comments or if you want to draw them into the discussion. Put the @ before a username to mention someone.

Make the discussion title or question as descriptive as possible. A good discussion title is a short preview of your post and is what gets people to click and read. A well written title is also going to help search engines better index your post which will bring more people into the discussion. For example, instead of ‘Won’t Connect,’ try ‘Help, I’m having problems getting my Acme modem into bridge mode.’

Additionally, you can format any code examples as such by using the "code" option under the paragraph symbol on the editor's toolbar. You'll find other options under that menu for formatting quoted text and marking "spoiler" content.

As a best practice in threaded discussions, begin your replies with quoted text from the post to which you're responding. That will keep conversations clear. Also, link to other discussion and code critique threads whenever appropriate.

Take ownership. Most important of all, take ownership of the discussions that you have created. Respond to comments promptly and thoughtfully. Thank others for commenting on your discussion and help with moderation if things get heated.

For the first time in a CCSWG, you can see the discussions and code critiques from the previous forums in this forum. However, you cannot continue those discussions on those threads.

We hope you enjoy this online working group!

Be sure to include the following:

• Title
• Author/s
• Language/s
• Year/s of development
• Software/hardware requirements (if applicable)

Then, place any context and questions you have about the code. It's helpful if you point the conversation in a direction.

Then include your code snippet. Use the code tags to access our context highlighting.

You can format code by

1. highlighting it in the forum editor
2. clicking the paragraph or pilcrow (¶) button in the editor bar
3. selecting "code"

...OR by adding three backtick marks ``` on a line directly above your code and on the line directly below as well.