As Mark Marino has explored in chapter four of Critical Code Studies (MIT Press, 2020), there are some are some rather nasty media assemblages out there eager to take snippets of climate code out of context. This can make a person a bit nervous about any attempt to offer even constructive constructive critique of this code (This is why I'm posting this so late into the working group... I've spent the last four weeks fretting over this, worried that even the most minor poetic flourish on my part might be taken out of context...)

The "aura of anxiety" surrounding this code is very much the result of over four decades of disinformation campaigns directed against climate science (Oreskes and Conway 2010) by those who wish to reap temporary benefits from fossil fuel capitalism (Storm 2009). These "merchants of doubt" are quite ready to use any excuse they can find to claim the climate scientists are "overreacting."

That is why I feel it is important to say, right out of the gate, that from what I learned while exploring this code, the scientists are actually underreacting.

If anything, the scientists have been, perhaps, too timid with their presentation of the severity of what these data indicate.

Any discussion of climate struggle should also be prefaced with a critique of "crisis epistemology," as has been offered by Indigenous philosopher Kyle Powys Whyte (Potawatomi) in "Against Crisis Epistemology" (2021). Whyte blends Indigenous histories with critical theory to argue against the use of "crisis" to frame the climate struggle.

This is not because the struggle to stabilize the climate isn't dire (It is.), but rather, because the rhetoric of "crisis" has been used for centuries to rob Indigenous groups of land rights. This issue should be of particular concern to environmentalists, since research continues to show that giving Indigenous people their land back may be one of our best tactics to mitigate climate change and other forms of ecological peril (Etchart 2017, ICCA 2021).

This critique of "climate crisis epistemology" was brought into sharp relief in settler occupied Washington State in 2021, when colonial magistrate Jay Inslee evoked the rhetoric of "climate crisis" in a broad move that robbed Indigenous groups of decision-making power over their ancestral lands. This move happened in the backdrop of the colonial government's practice of regularly allowing corporations to remove ecosystems on public lands, as exemplified by Washington State DNR's regular practice of allowing corporations to clearcut publicly-owned "legacy forests," which contain mature trees over 120 years old with diameters wider than four feet (Seattle Times 2021, C4RF.org), making them invaluable carbon sinks (Whitehead 2011).

With one face, the colonial government evokes "climate crisis" as its reason to remove Indigenous decision-making powers over their ancestral lands, while, with its other face, it gives logging firms free rein to clearcut public forests. As Kyle Whyte has emphasized, the "climate crisis" rhetoric has simply become a new way to justify a "state of exception" (Agamben 2005) in which Indigenous sovereignty is suspended, while those who actively harm the climate and ecology are given free rein.

Again, this shouldn't undermine the seriousness of climate struggle—it simply means lending more care to how this struggle is communicated, while working to better center Indigenous voices in climate discourse.

Any conversion about climate in these times also must be prefaced with a critique of the concept of the "population bomb," as has been laid out by Emily Klancher Merchant in her book Building the Population Bomb (Oxford University Press, 2021).

The myth of “the population bomb,” or the belief that population in and of itself drives ecological destruction remains pervasive among climate activists, scientists, and even some thinkers in the humanities. There is little evidence, however, that more people inherently generate more emissions, or that reducing the number of people on the planet would reduce emissions.

As Merchant shows, the concept of the "population bomb" was invented by eugenicists in the middle of the twentieth century, and then was promoted by American businessmen as a means of stalling environmental regulation. Reductive equations that link population and emissions distract us from publicly addressing the activities that directly fuel emissions, while foreclosing upon successful tactics for reducing emissions that simply aren't visible when taking such a hyperopic view.

File: zchunk_L251.en_ssp_nonco2.R]
Programming Language: R
Developed: 2017
Authors: Paralit Patel, pkyle, kvcalvin, mbins
Source File: https://github.com/JGCRI/gcam-core/blob/master/input/gcamdata/R/zchunk_L251.en_ssp_nonco2.R
Interoperating Files: GCAM (https://github.com/JGCRI/gcam-core/releases), The SSP database V.2 (https://tntcat.iiasa.ac.at/SspDb)
Note: In the parlance of climate modellers, this is a run of the GCAM5 under SSP1/5, SSP2, and SSP3/4.

# Copyright 2019 Battelle Memorial Institute; see the LICENSE file.

#' module_emissions_L251.en_ssp_nonco2
#'
#' Produce regional non-CO2 emissions coefficient data for SSPs 1/5, 2, and 3/4 as well as a GDP control.
#'
#' @param command API command to execute
#' @param ... other optional parameters, depending on command
#' @return Depends on \code{command}: either a vector of required inputs,
#' a vector of output names, or (if \code{command} is "MAKE") all
#' the generated outputs: \code{L251.ctrl.delete}, \code{L251.ssp15_ef}, \code{L251.ssp2_ef}, \code{L251.ssp34_ef}, \code{L251.ssp15_ef_vin}, \code{L251.ssp2_ef_vin}, \code{L251.ssp34_ef_vin}. The corresponding file in the
#' original data system was \code{L251.en_ssp_nonco2.R} (emissions level2).
#' @details This section takes in the non-CO2 emissions factors for SSP 1/5, 2, and 3/4 across sectors.
#' First, create data that spans the years 2010-2100 in five year increments by interpolation of input data.
#' Next, add emissions controls for future years of vintaged technologies for SSP emission factors.
#' Then, add columns that have regional SO2 emission species.
#' A GDP control of regional non-CO2 emissions in all regions is also created.
#' @importFrom assertthat assert_that
#' @importFrom dplyr filter group_by left_join mutate select semi_join
#' @author CDL May 2017
module_emissions_L251.en_ssp_nonco2 <- function(command, ...) {
  UCD_tech_map_name <- if_else(energy.TRAN_UCD_MODE == 'rev.mode', "energy/mappings/UCD_techs_revised", "energy/mappings/UCD_techs")
  if(command == driver.DECLARE_INPUTS) {
    return(c(FILE = "emissions/A_regions",
             # the following files to be able to map in the input.name to
             # use for the input-driver
             FILE = "energy/calibrated_techs",
             FILE = "energy/calibrated_techs_bld_det",
             FILE = UCD_tech_map_name,
             "L161.SSP2_EF",
             "L161.SSP15_EF",
             "L161.SSP34_EF",
             "L201.nonghg_steepness",
             "L223.GlobalTechEff_elec"))

  } else if(command == driver.DECLARE_OUTPUTS) {
    return(c("L251.ctrl.delete",
             "L251.ssp15_ef",
             "L251.ssp2_ef",
             "L251.ssp34_ef",
             "L251.ssp15_ef_elec",
             "L251.ssp2_ef_elec",
             "L251.ssp34_ef_elec",
             "L251.ssp15_ef_vin",
             "L251.ssp2_ef_vin",
             "L251.ssp34_ef_vin"))
  } else if(command == driver.MAKE) {

    year <- value <- GCAM_region_ID <- Non.CO2 <- supplysector <- subsector <-
      stub.technology <- agg_sector <- MAC_region <- bio_N2O_coef <- future.emiss.coeff.year <-
      SO2_name <- GAINS_region <- emiss.coeff <- technology <- minicam.energy.input <-
      tranSubsector <- tranTechnology <- input.name <- efficiency <-
      future.emiss.coeff.year <- NULL # silence package check.

    all_data <- list(...)[[1]]

    # Load required inputs
    get_data(all_data, "emissions/A_regions") ->
      A_regions
    get_data(all_data, "L161.SSP2_EF") ->
      L161.SSP2_EF
    get_data(all_data, "L161.SSP15_EF") ->
      L161.SSP15_EF
    get_data(all_data, "L161.SSP34_EF") ->
      L161.SSP34_EF
    get_data(all_data, "L201.nonghg_steepness") -> L201.nonghg_steepness
    L223.GlobalTechEff_elec <- get_data(all_data, "L223.GlobalTechEff_elec")

    # make a complete mapping to be able to look up with sector + subsector + tech the
    # input name to use for an input-driver
    bind_rows(
      get_data(all_data, "energy/calibrated_techs") %>% select(supplysector, subsector, technology, minicam.energy.input),
      get_data(all_data, "energy/calibrated_techs_bld_det") %>% select(supplysector, subsector, technology, minicam.energy.input),
      get_data(all_data, UCD_tech_map_name) %>% select(supplysector, subsector = tranSubsector, technology = tranTechnology, minicam.energy.input)
    ) %>%
      rename(stub.technology = technology,
             input.name = minicam.energy.input) %>%
      distinct() ->
      EnTechInputNameMap

There are 309 more lines. If you want to see the whole thing, go to: https://github.com/JGCRI/gcam-core/blob/master/input/gcamdata/R/zchunk_L251.en_ssp_nonco2.R

The thing I find interesting about this code, along with the larger assemblages it is part of, isn't what's there, but what isn't there.

First, I should explain that when you run this code and plot the data, you're going to wind up with a graph that looks somewhat like this:

You've probably seen this graph. It has made rounds in the media, and it has been part of the most recent meetings of the IPCC and COP. Indeed, we are looking at the cat's pajamas of climate code! This is the big stuff—the CMIP-approved stuff! This code, and its assemblages, generate the predictive climate data that inform leaders at the highest levels of government, along with the media and the public, as we attempt to collectively make decisions about what happens next.

The process of developing, reviewing, and running the scenario-models that produced this graph took roughly seven years to complete, and the parameters for the models and the data have been gone through many rounds of professional examination and peer-review before receiving their CMIP endorsement. CMIP stands for Climate Model Intercomparison Project, and the CMIP may be thought of as an ensemble of over 100 endorsed models from over 50 modeling institutions that work somewhat like an orchestra to model different aspects of the climate (ECMWF 2021), (WCRP).

Each major run or "phase" of the CMIP corresponds with a new IPCC climate assessment cycle. Each five-year cycle centers the development and presentation of an Assessment Report (AR) that draws upon the predictive climate data generated by the CMIP. We are currently at the end of the 6th IPCC assessment cycle, with the CMIP6 having been run in roughly 2017-18 and the AR6 having been offered to policymakers and the public in 2021. Presently, models and parameters are being prepared, adjusted (to fit the latest research), and reviewed for the 7th phase of the CMIP, which, once completed, will inform the AR7, which will last from 2023-2028.

Here at the CCSWG, we are readers--readers of code, and sometimes other things.

Looking at the graph above, the reader might find themselves in a bit of quandary, asking, "How should I interpret this graph? How should I read it?"

The way many of us have been taught to interpret the above graph (and even some scientists read it this way) is to point to the top two lines and say, “Those are the worst-case scenarios.” And then we are supposed to gesture towards the colorful lines at the bottom and say, “That’s the good outcome.” We then often look towards the middle-lower lines and assume that we can sort of average everything together and say, "Those lines down there, the middle ones, that must be the path we are on."

The trouble is... that is not how to read this graph.

To get a sense of how this graph should actually be read, you need to get a bit more familiar with the code and data that produced it.

If you look up at the above code snippet, in Lines 30-32, we can see a spot in which the SSP scenario data is being plugged into the GCAM planetary model:

30.              "L161.SSP2_EF",
31.              "L161.SSP15_EF",
32.              "L161.SSP34_EF",

The GCAM, or Global Change Analysis Model, is an open source model of the planet, and it may be downloaded here on GitHub. The GCAM has been developed in a colaboratory effort between multiple labs, and an article documenting the design of the latest version by Katherine Calvin and her co-authors may be found in issue 12 of the journal Geoscientific Model Development. (Note: the above code snippet was co-authored by one of the co-authors of this paper, so we can assume this code snippet was at least partially composed by someone involved with the creation of the model itself!)

The GCAM is one of six models of Earth that the SSP data is designed to run on (Riahi et al. 2017). The other five planetary models (in case you are curious) are the AIM/CGE, the IMAGE, the MESSAGE-GLOBIOM, the REMIND-MAgPIE, and the WITCH. (The WITCH has a rather fun online tool, MAGICC, that includes an online modeling interface you can use to run the SSP data or input a social scenario of your own—this is a very good tool for students who might be new to coding, and you can even use it to run the SSPs without needing any knowledge of coding 🧙‍♀️).

The SSPs are a set of ready-made data sets that represent different scenarios that are designed to be run through these six CMIP-approved models of Earth. There are five scenarios, the SSP 1-5, and the things that happen in them depend upon what the humans in the models do. Each "scenario" is treated as a possible path we might take in the time we have left before catastrophic levels of increased global temperature are locked in.

You can download the SSP scenario data straight from its source, the IIASA SSP Database (you have to create an account to access the data, which takes a couple minutes). If you're in a hurry, you can glance over the SSP1-5 data here on GitHub. (Each of the five files contains all of the data for one of the SSP scenarios). Scenario 1 (or SSP1) is the most optimistic, while the fifth scenario, the SSP5 is the least.

The emergence of the SSP scenarios is briefly explored by Brian O’Neill and his co-authors in issue 9 of Geoscientific Model Development. In this article, we learn that it was not until the most recent phase of the CMIP, the CMIP6, that the scenarios (which were previously limited to the RCPs) were removed from the core experiment and became their own MIP, the ScenarioMIP, (and the scenarios themselves were renamed the SSPs). Parsing the scenarios from the core experiment in this way has opened up space for more time and attention to be spent refining the scenarios.

The scenarios, it should be emphasized, are the only part of the CMIP's predictive climate data that factors in the role of social activities upon future emissions.

Since the last CMIP, the modeling community that creates the Scenarios has been working to bring more voices into the process of developing the Scenarios. In 2019, these communities hosted the first Scenarios Forum, an event bringing together "a diverse set of communities" to engage with the Scenario models to "exchange experiences, ideas...and identify knowledge gaps for future research." These scenario modelers have continued to acknowledge a need for feedback, including a "particular need for social sciences to inform scenarios on societal dynamics and tipping points" O’Neill et al. 2020.

My hope, I suppose, with this critique, is to show how voices from the humanities many also be valuable to the efforts to develop, refine, and share these scenario-models. Likewise, I do think that the humanities would benefit from lending its artful tools towards the scenario-models of CMIP and other efforts to model the planet--as Katherine Buse has emphasized in her compelling work that treats climate models as a medium in their own right.

Returning to my reading of the above graph, alongside its attendant code and data assemblages, I perceive this graph to be telling me a type of story, or multiple stories, about the future; the actual future, or what Genette has called "nonfiction diegeses" (1980). A diegesis might be thought of as a storyworld, and we usually think of these in fiction settings, such as the diegesis of the MCU or of the Star Trek Universe. There are nonfiction diegeses as well, and sometimes it can be bumpy to bring everyone into the same nonfiction diegesis, but this is required for any form of collective action.

The active process of collectively working your way into a shared narrative about reality that facilitates action has been called "frame alignment" by cultural theorist Robert Carley (Culture and Tactics, SUNY Press, 2018; cf. Gramsci 2011).

So, each line on the graph represents a different story about the future, a story that is also represented by the SSP scenario data set that was used to generate that line on the graph. You cannot average these lines together anymore than you could average together the works of Shakespeare. Each of these sets of scenario data is its own independent story, its own nonfiction narrative about the fate of the world.

Perhaps we are now beginning to suspect that we should be suspicious of those who tell us to read the graph as if the lower-middle lines represent the path we are on...

What exactly are these scenarios though? What are the stories that each set of SSP data purports to tell?

There are five "official" SSP Narratives that are used to explain why the numbers are set the way they are in each of the SSP data sets. (Riahi et al. 2017).

Here are the first two narratives, which are used to explain the two most "optimistic" emissions scenarios, the SSP1 and the SSP 2:

SSP1 Sustainability – Taking the Green Road (Low challenges to mitigation and adaptation)
The world shifts gradually, but pervasively, toward a more sustainable path, emphasizing more inclusive development that respects perceived environmental boundaries. Management of the global commons slowly improves, educational and health investments accelerate the demographic transition, and the emphasis on economic growth shifts toward a broader emphasis on human well-being. Driven by an increasing commitment to achieving development goals, inequality is reduced both across and within countries. Consumption is oriented toward low material growth and lower resource and energy intensity.

SSP2 Middle of the Road (Medium challenges to mitigation and adaptation)
The world follows a path in which social, economic, and technological trends do not shift markedly from historical patterns. Development and income growth proceeds unevenly, with some countries making relatively good progress while others fall short of expectations. Global and national institutions work toward but make slow progress in achieving sustainable development goals. Environmental systems experience degradation, although there are some improvements and overall the intensity of resource and energy use declines. Global population growth is moderate and levels off in the second half of the century. Income inequality persists or improves only slowly and challenges to reducing vulnerability to societal and environmental changes remain.

The other three narratives can be found in this paper by Keywan Riahi and his co-authors (2017).

It is worth noting that the present SSP data also include a rather problematic relationship between "population" "GDP" "investment" and "policy." I will save that critique for another day, as it falls more into the realm of social science.

Needless to say though, as a reader, I am having quite a bit of trouble suspending my disbelief for the "optimistic" scenarios--both because I do not find the narratives compelling enough to convince me that they will actually happen, and because as I pour through the data, I can find nothing to support that these scenarios are suggesting evidence-based types of social organizing changes that would be needed to us steer away from the course we are on.

This isn't to say that I don't have a level of optimism. I just want to be convinced.

I am a very picky reader, and it is going to take an extra amount of work to convince me to suspend my disbelief.

Currently, according to IEA estimates, we are on a path to create a 6°C rise in global temperature by 2100. Likewise, the tiny "dip" in emissions that occurred at the start of the pandemic quickly vanished as companies turned towards cheaper forms of fossil fuel, including coal, to deal with economic woes (Tollefson 2020, IEA 2021).

That is the path we are currently on:

A 6°C rise locked in less than 80 years.

It is a path so bad, the scientists didn't think to include it in the SSP scenarios

The Y-axis on the above graph doesn't even go that high.

This continued acceleration in emissions comes despite survey data that shows that 64% of people in 50 countries representing half the world's population believe climate change is a global emergency (UNDP-Oxford 2019). It also comes despite research that shows that 62% of Americans say that climate change has effected them personally (Pew 2021).

This is not a matter of political will: the majority of people already want to change the emissions course we are on. There is something else at play...

This isn't to say that there is no data in the SSPs to back up the emissions drops.

There is, in fact, plenty of data in the scenarios about emissions going down--but it all centers specific, practical actions: more solar, less coal, etc.

There is nothing, however, in the data that explains the types of social intervention that would need to happen to allow these changes to occur.

I want there to be a compelling reason for any emissions dip in the stories these scenarios tell, otherwise, as an audience member, I am going roll my eyes and yawn. I am going to feel like I’m stuck watching a B-rated movie in which the actions of the protagonists simply aren't even feasible, my engagement waning, as the theatre around me starts to burn.

For any drop in emissions in these scenarios/narratives, I want that dip to be linked to an evidence-based change in the institutions and power structures that mediate our lives.

By "evidence-backed," I mean, I want evidence that shows these changes to the social structure would reduce emissions, or at least have a good chance of it.

Here's a bit of evidence that gives me hope:

• One study looking at 72 countries over a 30 year period found that a one unit increase in a country’s score on the women’s political empowerment index was associated with an 11.51% decrease in the country’s carbon emissions (Lv and Deng 2019).
• Reducing racism has been associated with reductions in emissions (Stephens 2019, Johnson 2020)
• Restoring Indigenous peoples’ decision-making power over their ancestral lands is an emissions-reducing tactic—and this is backed up by geospatial satellite data (ICCA 2021).
• Transitioning from investor-owned to cooperatively-owned business structures has likewise been explored as a promising tactic to reduce emissions (ICA-EU 2021).

Why not put together some Scenarios that link emission drops to factors like these?

Beyond lending plausibility, adding these evidence-backed factors to the equation would give me, as a reader of the code, some protagonists to root for.

Correction: An earlier version of this piece contained the phrase "previously called the RCPs" rather than "previously limited to the RCPs."

"A quine is a computer program which takes no input and produces a copy of its own source code as its only output" (Wikipedia) and this particular quine is a "Ruby program that generates Rust program that generates Scala program that generates ...(through 128 languages in total)... REXX program that generates the original Ruby code again."

Yusuke Endoh is a member of the Ruby language's core-team. Ruby is a language known for having a beginner-friendly syntax and a welcoming community. It is, supposedly, a language "optimized for programmer happiness" and not for compiler happiness. In other words, Ruby leverages techniques such as syntactic sugaring to create its approachable syntax.

Nothing, in this program, seems approachable to me. How can I even begin analysing it?

eval$s=%q(eval(%w(B=92.chr;g=32.chr;puts(eval(%q(N=10.chr;n=0;e=->s{Q[Q[s,B],?"].K(N,B+?n)};E=->s{'("'+e[s]+'")'};d=->s,t=?"{s.K(t){t+t}};def~f(s,n)s.K(/.{1,#{n*255}}/m){yield$S=E[$s=$&]}end;Q=->s,t=?${s.K(t){B+$&}};R=";return~0;";V=->s,a,z{s.K(/(
#{B*4})+/){a+"#{$&.size/2}"+z}};C=%w(System.Console~Write);$C=C*?.;$D="program~QR";$G="~contents~of"+$F="~the~mix!g~bowl";$L="public~static";rp=->s,r{v="";[r.!ject(s){|s,j|o={};m=n=0;s.size.times{|i|o[f=s[i,2]]||=0;c=o[f]+=1;m<c&&(m=c;n=f)};v=n+v;
s.K(n,(j%256).chr)},v]};%(fn~mX{Z`x21("{}",#{E["object~QR~extends~App{#{f(%((display~"#{e[%(Zf("1d;s/.//;s/1/~the~sum~of~a~son~and0/g;s/0/~twice/g;s/2/`x59ou~are~as~bad~as/g;s/3/~a~son`x21Speak~your~m!d`x21/g^n#The~Relay~of~Qu!e.^n#Ajax,~a~man.^n#
Ford,~a~man.^n#Act~i:~Qu!e.^n#Scene~i:~Relay.^n#[Enter~Ajax~and~Ford]^n#Ajax:^n#");function[]=f(s);for~i=1:2:length(s),Zf("2%s3",part(dec2b!(hex2dec(part(s,i:i+1))),$:-1:2)),end;endfunction`n#{s,v=rp["Transcript~show:~'#{d["Z"+E[%(fun~p~n=Z(Int.to
SJ~n`x5e"~");fun~mX=(p~0;p~0;p~130;List.tabulate(127,p);SJ.map(fn~c=>(p(3+ord~c);Z"-1~0~";c))#{E[~~~~~~%(object"Application"{state"ma!"{foreach(s~![#{f(%(puts~"#{Q[e[%(echo~'a::=`x7e#{Q[Q["let~s=#{E[%(void~p(!t[]c){foreach(!t~v~!~c)stdout.Zf("%c%c
",v/256,v%256);}void~mX{!t[]a;p({19796,26724,0,6,0,1,480,19796,29291,#{s=%(module~QR;!itial~beg!~#{f("let~s=#{E[%(Module~QR:Sub~MX:Dim~s,n,i,c~As~Object:n=Chr(10):For~Each~c~!"#{d["<?xml#{O="~version='1.0'"}?><?xml-#{I="stylesheet"}~type='text/xsl
'href='QR.xslt'?><xsl:#{I+O}~xmlns:xsl='http://www.w3.org/1999/`x58SL/Transform'><xsl:output~method='text'/><#{U="xsl:template"}~match='/'><`x21[CDATA[#{%(sub~f(s$,n)Z(s$);:for~i=1to~n~Z("Y");:next:end~sub:f("#{V[e[%(H,format="#{y="";f("^H{-}{txt}
{#{Q["echo~-E~$'#{Q[Q[E[%(with~Ada.Text_Io;procedure~qr~is~beg!~Ada.Text_Io.Put("#{d[%(trans~B(Buffer)`ntrans~O(n){`nB:add(Byte(+~128~n))}`ntrans~f(v~n){`nO(+(/~n~64)107)`nO(n:mod~64)`nO~v}`ntrans~D(n){if(<~n~4){f(+(*~6~n)9)48}{if(n:odd-p){D(-~n~3
)`nf~27~48`nf~36~11}{D(/~n~2)`nf~21~48`nf~48~20}}}`ntrans~S(Buffer"#{e[%W[STRINGz:=~226+~153,a:=z+~166,b:=a+"2"+z+~160,c:=b+"8"+z+~165,t:="#{d[%(class~QR{#$L~void~ma!(SJ[]a){a=#{E["H('#{Q[e["implement~ma!0()=Z"+E["BEGIN{Z#{E[%(echo~'#{%(f(s){Syste
m.out.Z(s);}s="389**6+44*6+00p45*,";for(c:#{E[(s="#!clude<iost ream>`n!t  ~mX{std::cout<<#{E[%(class~Program{#$L~void~MX{#$C("Qu!e~Relay~Coffee.^n^nIngredients.^n");for(!t~i=9;i++<126;)#$C($"{i}~g~caffe!e~{i}^n");#$C("^nMethod.^n");foreach(char~c~
!#{E[%((doseq[s(lazy-cat["IDENTIFICATION~DIVISION." "PROGR     AM-I      D.~QR.""    PROCEDURE~DIVISION."'DISPLA`x59](map~#(str"~~~~^""(.replace~%1"^"""^"^"")"^"")(re-seq~#".{1,45}""#{e["(f=(n)->Array(n+1).jo!~'Y');console.log('%s',#{V[E[%((H-l!e"
#{e["import~std.stdio;void~mX{H(`x60#{%(method~MX   {Z(       @                     "#{d["['']p[#{"IO.puts"+E[%((pr!c~"#{e["`nma!(_)->`nio:fH#{d[E['Zfn("""'+d[?"+"%opti                on~noyywrap`n%%`n%%`n!t~mX{puts#{E["echo~'#{Q[Q[%(~:~A~."#{g*9}
"~;~:~B~A~."~WRITE(*,*)'"~A~;~:~C~B~T`x59PE~."~    '"                                          ~CR~;~:~D~S"~#$D"~C~S^"~Z~^"(&"~C~S^"~#{e[%(Z"#{e["s:=OutputTex                                  tUser();WriteAll(s,#{E[%(Zf"#{e[d[f(".template~1`n#{d['
set~Z"-";Z'+E[%(package~ma!;import"fmt";func~                                                mX{fmt.Pr!t#{E[%(236:j;{119:i;{206i-:i;.48<{71+}{[i]^48-*}if                                            }%}:t;"algoritmo~QR;!"[195][173]++'cio~imprima("'"
013141"t"/12131"t~6*"/1:1918151:??6271413/4=                                                        3626612/2/353251215/`x5a0`x5a0R"t"#{e[%(z=new~jav                                                    a.util.zip.G`x5aIPOutputStream(System.out);z.H
('#{"ma!=putStr"+E["class~QR{#$L~function~m                                                             X{neko.Lib.Z#{E[%(procedure~mX;i:=c:=0;s:=                                                          #{E[%(.class~public~QR`n.super~#{$T="java/i
o/Pr!tStream"}`n.method~#$L~ma!([L#{S="ja                                                             va/lang/S"}J;)V~;]`n.limit~stack~2`ngetst                                                                atic~#{S}ystem/out~L#$T;`nldc~"#{e[%(cla
ss~QR{#$L~void~ma!(SJ[]v){SJ~c[]=new~SJ     [999                                                           99],y="",z=y,s="#{z=t=(0..r=q=126)                          .map{|n|[n,[]]                             };a="";b=->n{a<<(n%78+55)%84+42};(%(P
={0:'[+[]]',m:'((+[])'+(C="['construct     or']"                                                               )+"+[])['11']"};for(R~!~B=('                     `x21[]@`x21`x21[]@[][[]]@'+(                       A="[]['fill']")+"@([]+[])['fontcolor
']([])@(+('11e20')+[])['split']([])@"      +A+C                                                              +"('return~escape')()("+A+'                   )').split('@'))for(E~!~D=eval(G='('+B[                    R]+'+[])'))P[T=D[E]]=P[T]||G+"['"+
E+"']";for(G='[',B=0;++B<36;)P[D=B.to                      SJ(36)]=B<10?(G+='+`x2                                1+[]')+']':P[D]||"(+('                 "+B+"'))['to'+([]+[])"+C+"['name']]('36')";A                   +=C+"('console.log(unescape(^"";
for(E~!~G=#{E[%(Z("""#{Q[e[%(s=();a()  {~s+         =($(echo~-n~$1|od~-An~-tu1~-v)~$2)                              ;};a~"Section`x48                eader+name:=QR;SectionPublic-ma!<-("~10;t='#{"cons                 ole.log"+Q[E[%(@s=global[#{i=(s
=%(`x48AI~1.2`nVISIBLE~"#{"x=sJ.K(#{V[E  ["changequote(<@,@>)`ndef!e(p,<@#{"all:`n`t@echo~                            '#{d["l!el:99                999;Z#{E["solve~satisfy;output~[#{E[%(.assembly~t{}.me                 thod~#$L~void~MX{.entrypo!t~l
dstr"#{e["m{{`x21:~x`nqr:~|-`n~:db`x     60#{e[s="$Z#{E["Zf#{E["echo"+E["#import<stdio.h>#{N                         }!t~mX{puts#                {E["Z_sJ"+E["s=double#{E["Z#{E["$console:l!e[#{"#$D(output                );beg!~H(#{f((p="eval";%($_=
"#{s,v=rp["$_='#{Q[%(<?php~$z=3+$      w=strlen($s=#{Q[E["!t~mX{H#{E["(#{?_*11})dup~=/s(|~~~~~.                         ~~~|)def               (#{Q["qr:-H('#{Q[e["!it{#{f(%(Z('cat("')`nfor~c~!"".jo!(["ech                o~'say~''%s'''^n"%l~for~l~!
#{E[d[d["eval$s=%q(#$s)",?'],?']     ]}.split("^n")]):Z('r=fput(char(%d))'%ord(c))`nZ('end^n")')#                         ),6)               {"Zf#{d[$S,?%]};"}}}"],?']}').",B]}){9~7{exch~dup~1~and~79~mul~32               ~add~exch~2~idiv~3~1~roll~
s~exch~2~!dex~exch~put~1~sub~d      up~6~eq{1~sub}if}repeat~s~=~pop~pop}forall~=~quit"]+R}}"]]})*3;                        ec   ho"^x89PNG^r^n^x1a^n";$m="";$t="^xc0^0^xff";for($i=-1;++$i<128*$z;$m.=$c--?($w-              $c||$i>$z)&&$i/$z<($c<$w?o
rd($s[(!t)($c/3)]):$c--%3+2)      ?$t[2].$t[$c%3%2].$t[$c%3]:"^0^0^0":"^0")$c=$i%$z;foreach(array("I`                     x48DR"                 .pack("NNCV",$w+2,128,8,2),"IDAT".gzcompress($m),"IEND")as$d)ec              ho~pack("NA*N",strlen($d)
-4,$d,crc32($d));).K(B,"`x7      f"),?']}';s:g/^x7f/Y/;Z~$_",128..287];s="$_='#{Q[s,c=/['Y]/]}';$n=32;$                                                      s='#{Q[v,c]}';$s=`x7es{..}{$a=$&;$b=chr(--$n&255);`               x7es/$b/$a/g;}eg;Z";(s+N
*(-s.size%6)).unpack("B*")      [0].K(/.{6}/){n=$&.to_i~2;((n+14)/26*6+n+47).chr}}";s|.|$n=ord$&;substr~                                                           unpack(B8,chr$n-!t($n/32)*6-41),2|eg;eval~pack              'B*',$_).scan(/[~,-:A-z]
+|(.)/){p="s++#{$1?"chr~#      {$1.ord}+e":$&+?+};"+p};p),1){"'#$s',"}}'')end.".K(/[:;()]/){?`x5e+$&}}]"]}                                                              ;quit"]};t=num2cell(b=11-ceil(s/13));for~              n=1:9m={};for~i=1:141f=@
(x,y,n)repmat(['Ook'~char      (x)~'~Ook'~char(y)~'~'],[1~abs(n)]);m(i)=[f(z=46,63,n)~f(q=z-(i<13)*13,q,i-1                                                                 3)~f(33,z,1)~f(63,z,n)];end;t(x=b==n)              =m(diff([0~s(x)])+13);en
d;Zf('%%s',t{:})"]]+R}}"      ]]}`n"]};"]}`x60`n~global~_start`n~_start:mov~edx,#{s.size}`n~mov~ecx,m`n~mov~e                                                                   bx,1`n~mov~eax,4`n~!t~128`n~mov~eb              x,0`n~mov~eax,1`n~!t~12
8`nx:~|`n~}}{{{qr}}}"]}"      call~void~[mscorlib]#{C*"::"}(sJ)ret})]}];"]};quit();",?$].K(?'){"'^''"}}'"}@>)`                                                                     np"],?&,?&]},'&(%d+)&',function              (s)return~sJ.rep('Y',to
number(s))end);Z(x)".K(       /[:"]/,":^0")}"`n`x4bT`x48`x58B`x59E~B`x59E)).size+1}x~i8]c"#{s.K(/[^"`n`t]/){"^%0                                                                      2`x58"%$&.ord}}^00"declare~               i32@puts(i8*)def!e~i32@
mX{%1=call~i32@puts(i8*       getelementptr([#{i}x~i8],[#{i}x~i8]*@s,i32~0,i32~0))ret~i32~0})],?#].K(?',%('"'"'))                                                                        }';for((i=0;i<${#t};i+=9              9));do;x=${t:$i:99};a~"^
"${x//[Y^`"]/Y^0}^".Z;"       ~10;done;a~");";p(){~echo~-n~$1;};f(){~for~x~!~${s[*]};do;p~$3;for((j=$2;j--;));do  ;                                                                         h~$1~$x~$j;done;done;              };p~k^`x60;h(){~p~^`x60$
{1:$(($2>>$3&1)):2};};f       ~kki~7~'`x60`x60s`x60`x60s`x60`x60s`x60`x60s`x60`x60s`x60`x60s`x60`x60s`x60`x60s     i'                    ;s=();a~'A          G-`x                             48-`x48Fy.IlD==;=j               dlAy=;=jldltldltl{lAulAy
=jtlldlAyFy=?=jdlAyGFyF       yG2AFy>zlAFFBCjldGyGFy>GFy.AGy=G==n`x48==nlldC=j@=jtlldltldlAut11';h(){~p~${1:$        (                   ((($2%83-10)>     >((2-$3)*2)                          )%4)):1};};f~sk               i^`x60~3)]]}"""))]})A+="'
+`x21[]+'"+G.charCodeAt(       E).toSJ(16);for(A+="^".replace(/'+`x21[]+'/g,^"%^")))')()",R=0;R<9;R++)A=A.re          p                    lace(/'.*?'/g,  function(B){T=          [];fo          r(E=1;B[E+1]                ;)T.push(P[B[E++]]);retur
n~T.jo!('+')});console.l        og('"'+A+'"'))).bytes{|n|r,z=z[n]||(b[r/78];b[r];q<6083&&z[n]=[q+=1,[]];t[             n]                    )};b[r/78];b[r]}";!t~i=0,n=0,q=     0;for(;++n<1       26;)c[n]=                ""+(char)n;for(;i<#{a.size
};){q=q*78+(s.charAt(i)-1        3)%84;if(i++%2>0){y=q<n?c[q]:y;c[n++]=z+y.charAt(0);System.out.Z(z=c[q])             ;q=0                    ;}}}})]}"`n!vokevirtual~#$T/Zln(   L#{S}J;)V`nretur     n`n.en                d~method)+N]};H("DO,1<-#"||
*s);s?while~t:=ord(move(1)        )do{i+:=1;u:=-i;every~0to~7do{u:=u*2+t%2;t/:=2};H("PLEASE")^(i%4/3);H             ("DO,1SU                    B#"||i||"<-#"||((c-u)%256));c:=u ;};H("PLEASEREADOUT   ,1^                 nPLEASEGIVEUP");end)]};}}"].
tr(?"+B,"`x21`x7e")}'.tr('         `x7e`x21','Y`u0022')as~byte[]);z.close())]}"{"W""w"@j~1+:j^-~118%1              +*}%"/3551                     2416612G61913@921/17A331513"t'");fim')]};})],B]}`n.e n                  dtemplate",61){"Zn#$S`n"},?%]
]}"`nquit)]});CloseStream(s         );QUIT;"]}")]}"~DUP~A~."~DO~10~I=1,"~.~CR~S"~&A,&"~C~."~10~~~~~              ~CONTINUE"~CR~                      S^"~&A)^",&"~C~0~DO~B~."~&char("~COUNT~.~."~),&'"                   ~CR~LOOP~S^"~&^"^""~C~S"~end~#
$D"~C~A~."~STOP"~CR~A~."~END          "~CR~B`x59E~;~D~),B],?`x21].K(?',%('"'"'))}'"]};}".K(?"){'"3             4,"'}.K(N){'"10,"'                      }+?",?%]+'~""")'],?`x7e]}."]}"))]}]p['']pq"]}                   ");})}`x60);}"]}"))].K(?`x60,"Yx
60"),'#{f(',')}']})"]}"))["~~~          ~^"~^".""STOP~RUN."])](Zln(str"message(STATUS~^"~~~~~"(              .replace(.replace(str                        ~s)"Y""YY")"^"""Y^"")"^")")))).reverse]                     })#$C($"Put~caffe!e~{(!t)c}~!to#$
F.^n");#$C("Liquify#$G.^nPour#$           G~!to~the~bak!g~dish.^n^nServes~1.^n");}})]};}/****               //****/";t={};b="";L="";                          n=i=0;D=->n{L<<(n+62)%92+35;D};                       s.bytes{|c|n>0?n-=1:(t[c]=(t[c]||[]
).reject{|j|j<i-3560};x=[];t[c].m            ap{|j|k=(0..90).f!d{|k|not~s[i+1+k]==s[j+k]}|                |91;k>4&&x<<[k,j]};x=x.max)?                              (n,j=x;x=b.size;(u                            =[x,3999].m!;D[u%87][u/87];L<<b[0,u];
b[0,u]="";x-=u)while~x>0;x=4001+i-j             ;D[x%87][x/87][n-5]):b<<c;t[c]+=[i+=1]}                ;"#!clude<stdio.h>`nchar*p=#{E[L]}                                                                       ,s[999999],*q=s;!t~mX{!t~n,m;for(;*p;){
n=(*p-5)%92+(p[1]-5)%92*87;p+=2;if(n>                3999)for(m=(*p++-5)%92+6;m--;q                  ++)*q=q[4000-n];else~for(;n--;)*q++=*p                                                                   ++;}puts(s)#{R}}")]}){s+="00g,";for(m=1;m
<256;m*=2)s+="00g,4,:"+(c/m%2>0?"4+":""                     )+",";f(s);s="4                       ,:,";}f(s+s);for(c:Base64.getDecoder().decod                                                             e("kaARERE`x58/I0ALn3n5ef6l/Pz8+fnz58/BOf5/7
/hE`x58/O`x5azM5mC`x58/Oczm`x5azBPn5+`x58/                                                     OczMznBL/nM5m`x5azBPu++fPPOc5zngnnO`x5azO`x5agnBMG                                                       AW7A==")){c=c<0?256+c:c;for(i=0;i++<3;c/=8)f(c%
8);f("8*+8*+,");}f("@");).K(?',%('"'"'))}'|se                                               d~-e's/Y/YY/g'~-e's/"/Yq/g'~-e's/.*/Z~"&"^nquit/')]}}"]],                                               ?']}');".K(/^+/){"`x5e#{$&.size}`x5e"}]}.split("Y`x
5e");for(!t~i=1;i<a.length;a[0]+=a[i+1],i+=2){a[0]                                      +="Y".repeat(Integer.parseInt(a[i]));}System.out.Z(a[0]);}})]}";F                                       ORiTO`~UPBtDO`~INTn:=ABSt[i];Z(~(50+n%64)+c+~(50+n%8MOD
8)+c+~(50+nMOD8)+b+"`x4a"+a)OD]*"REPR"]}")`nwhile(`x21=(                         S:length)0){`ntrans~c(S:read)`nD(c:to-!teger)`nf~35~39}`nf~24~149`n!terp:librar                         y"afnix-sio"`ntrans~o(afnix:sio:OutputTerm)`no:H~B)].K(N,'"&Ch
aracter'+?'+'Val(10)&"')}");end;)]+"`nsys.exit~0",B],?']}'",/[^{}]/]}}",35){y<<",`n"+$S;"%s"}}")+y],'",','):f("']}",0))}]]></#{U}></xsl:#{I}>"].K~N,'"&~VbLf~&"'}":s="~~~":For~i=0To~7:s~&=Chr(32-(Asc(c)>>7-i~And~1)*23):Next:#$C(s~&n~&Chr(9)&n~&"~~"
):Next:#$C(n~&n~&n):End~Sub:End~Module)]}`nput=s`nZ`nqa`x21",3){%($H("%s",#$S);)+N}}end~endmodule);W=s.size*72+4;"%d,%d"%[W/65536,W%65536]}});foreach(!t~c~!#{E[s]}.data)foreach(!t~v~!~a={0,9,7,4,5,c/100*7/6+1,c%100/10*7/6+1,c%10*7/6+1,7})p({144,v=
15450+v*256,384,v});p({255,12032});})]},i=0,t='k';while(s[i])t='^x60.'+s[i++]+t;console.log(t)",B],?`x21].K(?',%('"'"'))}'"^n::=^na")],/[`[`]$]/]}"),4){$S+?,}}])Console.H(s);Application.exit();}})]};Z"0~0~-1");)],?']}';cr",127..255];f(%(variable~s
=`x60#{s.K(/.{1,234}/){$&.K("`x60",%(`x60+"`x60"+`x60))+"`x60+`n`x60"}}`x60,i;for(i=0;i<129;i++)s=strreplace(s,pack("C",255-i),substrbytes(`x60#{v[0,99]}`x60+`n`x60#{v[99..-1]}`x60,i*2+1,2));Zf("%s",s)),7){"f('%s')`n"%$s.unpack("`x48*")}}Zf("^n#[E
xeunt]");quit)]}")),196){%(Z#$S;)}}}"]});})).gsub(/[!HJKXYZ^`~]/){[B*2,:write,B,:tring,:gsub,"ain()",B*4,:print,g,:in][$&.ord%47%12]})))*"")#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_futu
#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffe
#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffe
#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffer_for_future_bug_fixes_#_buffe
####################################################################################  Quine Relay -- Copyright (c) 2013, 2014 Yusuke Endoh (@mametter), @hirekoke  ###################################################################################)

main( ) {
printf("hello, world");
}

The use of "hello, world!" as a test message was initially described as a code example in Dennis Ritchie and Brian Kernighan's 1978 book The C Programming Language. This simple program followed an earlier Bell Laboratories' internal memorandum written by Brian Kernighan in 1974, titled Programming in C: A Tutorial (see also Wikipedia, online).

The "hello, world!" program is probably one of the simplest programs to write, and often one of the first basic syntaxes to be learned by students and/or coders in several programming languages (eg. Ballerina, BASIC, Batch file, Bash, C, C++, C#, COBOL, Clojure, Dart, Elixir, Ezhil, Fortran, Go, Haskell, Java, JavaScript, Kotlin, Logo, Lua, mq, Objective-C, OCaml, Pascal, Perl, PHP, PowerShell, Prolog, Python, Ruby, Rust, Standard ML, Swift, TI-BASIC, Zig).

Since 1994, Wolfram Roesler and many people around the globe compiled The Hello World Collection, including 603 "hello, world!" programs in several programming languages and in additional 78 human languages. More recently, Geoff Cox and Duncan Shingleton created hallo welt! (hello world!), shown as a projection at BV Gallery, Linz (Austria) in 2008, and as part of AFTER THE NET, at Peninsula Arts Gallery, Plymouth (UK) in 2009, and at Tecnológico de Monterrey, Toluca (México) in 2010. Cox and Shingleton's brilliant codework plays on a communicative act between programmer and computer, by 'looping more than 100 Hello World programs written in different programming languages, alongside a selection of human languages, [and] combining them into a real-time, multilingual, machine-driven confusion of tongues' (Soon and Cox, 2020).

Discussion Questions

1. While most of the programming languages are based in English, some experiments to decolonize code can involve trying to use other (non-Western) languages?

2. What could these new code experiments with non-English languages look like?

3. Do you know of other examples of "hello, world!" programs in other languages than English?

4. How could the "hello, world!" bring new possibilities to teaching, learning and developing alternative modes of thinking and living that are non-Western?

5. How could we creatively re-think the "hello, world!" code as non-binary?

Play link: https://rcveeder.net/wooby/

In this text adventure, written for a virtual pet-themed game jam, the player visits an island populated by tiny felt dinosaurs. The dinosaur dolls are generated with different legs, necks, spikes or no spikes, teeth or no teeth...

This was all based on real dolls I had sewn, and given names like "Teggisaurus," "Dagadagadon," and "Mustadopagus." I wanted the generated dinosaurs to have generated names that were recognizable both as pseudo-baby talk and as dinosaur names.

(An extremely long commentary on the full dinosaur generation process is available for anyone interested.)

It strikes me that, in order to come across as stereotypical baby talk, the "roots" here run fairly long ("boofa," "smoosha"). When more than half of generated names contain more than one of these roots, I think you run into a lot of names that are too long to be, strictly speaking, cute.

A possible angle for discussion: Where else have you seen nonsense words generated to fit in a specific aesthetic? Do strategies for creating different "looks" for words have anything in common?

To name the current test subject:
    let tempname be text;
    let namecomponents be a random number between 1 and 2; [First randomize the number of "roots" that will be in the name. Right now it's 50% one root, 50% two roots.]
    if a random chance of 1 in 6 succeeds:
        increment namecomponents; [Now the distribution is 41.667% one root, 50% two roots, and 8.333% three roots. A dinosaur with three roots in its name turns out to be fairly inconvenient, so we will tone that third option down a little..]
    if namecomponents is 3:
        if a random chance of 2 in 3 succeeds:
            now namecomponents is 2; [Sow now we're looking at 41.6% one roots; 55.6% two roots; 2.8% three roots.]
    if namecomponents is 1:
        choose a random row in Table of Long Name Suffixes;
        now tempname is "[suffix entry]"; [A name with only one root requires a long suffix, since something like "Goomus" doesn't look dinosaury enough.]
    otherwise:
        if a random chance of 1 in 2 succeeds:
            choose a random row in Table of Long Name Suffixes;
            now tempname is "[suffix entry]";
        otherwise:
            choose a random row in Table of Short Name Suffixes;
            now tempname is "[suffix entry]";
    choose a random row in table of name roots;
    now tempname is "[root entry][tempname]";
    decrement namecomponents;
    if namecomponents is greater than 0:
        choose a random row in table of name roots;
        now tempname is "[root entry][tempname]";
        decrement namecomponents;
    if namecomponents is greater than 0: [Instead of repeating a loop until namecomponents reaches 0 like a real programmer would, why not write out all possible steps]
        choose a random row in table of name roots;
        now tempname is "[root entry][tempname]";
        decrement namecomponents;
    Now the species name of the current test subject is "[tempname]" in title case;
    now the printed name of the current test subject is "[tempname]" in title case. [The player can change the printed name of a dinosaur with a command like >NAME BUGGOBOGADON ALFIE.]



Table of Name Roots
root
"boofy"
"woofy"
"daga"
"boo"
"doo"
"goo"
"zoo"
"ruffy"
"smooshi"
"woobo"
"wooba"
"wooby"
"boofa"
"ragga"
"muffy"
"libby"
"zaka"
"bitty"
"itty"
"licky"
"grabby"
"buggy"
"buggo"
"dugga"
"duggo"
"grabbo"
"flippy"
"frumpa"
"smoosha"
"smooshy"
"darno"
"darmi"
"lecko"
"steggy"
"teggy"
"tyra"
"bumpo"
"humba"
"wumba"
"dunda"
"dooga"
"booga"
"boogy"
"oogy"
"wicky"
"slibba"
"normo"
"olly"
"goli"
"boli"
"doli"
"garda"
"cappy"
"pulla"
"wedder"
"veeda"
"josie"
"denny"
"dinky"
"rosy"
"ratty"
"hatty"
"chatty"
"darpo"
"poppy"
"gooby"
"linto"
"quibbo"
"bumpi"
"slibbi"
"gardi"
"veedi"
"denno"
"dinko"
"goobo"
"lizza"
"lizzo"
"harry"
"harpo"
"groucho"
"gummo"
"chico"
"zeppo"
"boga"
"goba"
"bago"
"gabo"
"dizzi"
"dizzo"

Table of Short Name Suffixes
suffix
"don"
"dax"
"nus"
"mus"
"rax"
"lus"
"lops"

Table of Long Name Suffixes
suffix
"saurus"
"dactyl"
"raptor"
"daptor"
"gaptor"
"zaptor"
"pitus"
"ceratops"
"cephalus"
"mimus"

Many of us will be familiar with Wordle, a popular game by created by Josh Wardle in which the player gets 6 chances to guess a five-letter word. The players gets to know which letters of their guess were in the solution-word (marked by a yellow or blue square) and whether those letters were in the correct position in the word (marked by a green or orange square).
Arguably the most interesting part of the game's popularity is its social element. When the game became popular in New-Zealand, people started share how many guesses they had needed. One player then created a grid of emoji squares to signify her process without spoiling the solution for others. After a share-button was added to the game, which copied your personal grid to your clipboard, it became easy to share and the game went viral. (source for this background is this interview with Wardle on Slate)

In addition to making the game go viral, each grid gives a little narrative that other players can understand. C Thi Nguyen wrote a Twitter thread about this which you can read here. He says that people got to know the game through "incomprehensible little box-chart graphics" but after playing the game you realize "Every game of Wordle is a particular little arc of decisions, attempts, and failures. But each little posted box is a neat synopsis of somebody's else's arc of action, failure, choice, and success."

Now in addition to the onslaught of Wordle grids on social media, my Twitter feed now seems to have one tweet complaining of the accessibility of those grids for every three Wordle tweets. Here's the problem: to screen reader users (such as blind/low vision people), the visual of the grid is read out linearly, which is little more than noise. On Twitter, people beg users to change up their way of sharing their wordle results without the use of emojis. Several programs have been made to convert the squares to a meaningful description. Wa11y, for example, lets readers paste their wordle result into their website and converts it into a "sharable" written version.

Wa11y's code is available on github. I am pasting a snippet of it below this post. The program labels yellow/blue squares as "hasMisplaced" and green/orange squares as "hasPerfect". Thus if there are only black squares (indicating that every letter of the guess was incorrect) it does not say '5 black squares' (or "black square black square black square black square black square" depending on which screen reader you were using) but simply returns "Nothing.", which is a more meaningful description of not getting any letter right. If there are 5 green/orange squares, the person has all letters correct, so the program returns "Won!"). If there is a mixture, it will return which position in the line is misplaced and which are perfect.

Wa11y is not the only program available, so if someone wants to reply with a comparison, go for it!
An example is Wordle Result Image Generator, which generates a shareable image and alt text for the image. Github link.
Another example is WordleBot, which adds explanations to the grid, but is still not useful to screen readers because it still includes all the square emoji's in the post: announcement link (I'm not sure the source code is available for this one)

Now the existence of Wa11y is very good, but sharing the grid of square emoji's has already become a habit for Wordle players and it is the simplest action. Telling every individual to change their behavior, then, will take a long time and meets resistance from players. So it makes much more sense for the Wordle website to provide both a grid and a text-based version for readers to avoid the extra step which is seen as a nuisance. I say both options, because people also share their results privately and if they know they are chatting to can and wants to see the grid, the written explanation is not necessary.

Going back to the narrative arc of the grid that C Thi Nguyen described, I am curious how different textual translations give a different narrative of the game. I was surprised, for example, when blind digital accessibility expert suggested ""Screenshot of Wordle score. Three rows of 5 squares. Bottom all green, middle alternate green & grey, top 2 yellow, 2 grey 1 green" which is a literal description, but arguably does not provide the same narrative. How do you think different programs create different narrative arcs for Wordle? How could this be improved?

There's much more to say, but I am interested to read what others have to comment, so I'll end here for now.

This is a snippet, the rest is available on https://github.com/cariad/wa11y.co):

let explanation = '';

if (!hasPerfect && !hasMisplaced)
explanation = 'Nothing.';
else if (decoded.perfectIndexes.length === 5)
explanation = 'Won!';
else if (decoded.misplacedIndexes.length === 5)
explanation = chopAggression >= 1 ? 'all in the wrong order.' : 'all the correct letters but in the wrong order.';
else if (hasPerfect && hasMisplaced)
explanation = ${perfect}${misplaced}.
else if (hasMisplaced)
explanation = ${misplaced}.
else
explanation = ${perfect}.

const prefix = chopAggression >= 5 ? ${num}. : Line ${num}:;

const result = ${prefix} ${explanation}\n

if (chopAggression >= 4)
return result.replaceAll(' and ', ' & ');

return result;
}

Title: ELIZA
Language: MAD-SLIP
Year: 1965
Author: Joseph Weizenbaum
System: IBM 7094

Dearly Beloved,

We are gathered here to analyze a version of Joseph Weizenbaum's original source code for ELIZA, recently discovered in MIT’s archives. You can read more about it [here].

Code below in Spoilers. But also in a syntax highlighted version by @DavidBerry

$s changed to "s
.EQ., etc. expanded to =, etc.
' abbreviations written out
continued lines (with a 1 in column 7?) wrapped together
line numbering removed
Added lisp-like comments (;;; ;; and ;)

            EXTERNAL FUNCTION (KEY,MYTRAN) 
            NORMAL MODE IS INTEGER 
            ENTRY TO CHANGE. 
            LIST.(INPUT) 
            Vector Values G(1)="TYPE","SUBST","APPEND","ADD","START","RANK","DISPLA" 
            Vector Values "NUMB = " I3 *" 
            FIT=0 
CHANGE      PRINT COMMENT "PLEASE INSTRUCT ME" 
            LISTRD.(MTLIST.(INPUT),0) 
            JOB=POPTOP.(INPUT) 
            Through IDENT, FOR J=1,1, J> 7 
IDENT       Whenever G(J) = JOB, Transfer To THEMA 
            PRINT COMMENT "CHANGE NOT RECOGNIZED" 
            Transfer To CHANGE 
THEMA       Whenever J = 5, Function Return IRALST.(INPUT) 
            Whenever J = 7 
                Through DISPLA, FOR I=0,1, I  > 32 
                Whenever LISTMT.(KEY(I)) = 0, Transfer To DISPLA 
                S=SEQRDR.(KEY(I)) 
READ(7)         NEXT=SEQLR.(S,F) 
                Whenever F > 0, Transfer To DISPLA 
                PRINT COMMENT "*" 
                TPRINT.(NEXT,0) 
                PRINT FORMAT SNUMB,I 
                PRINT COMENT " " 
                Transfer To READ(7) 
DISPLA          CONTINUE 
                PRINT COMMENT " " 
                PRINT COMMENT "MEMORY LIST FOLLOWS" 
                PRINT COMMENT " " 
                Through MEMLIST, FOR I=1 , 1, I > 4 
MEMLST          TXTPRT.(MYTRAN(I),0) 
                Transfer To CHANGE 
            End Conditional 
            THEME=POPTOP.(INPUT) 
            SUBJECT=KEY(HASH.(THEME,5)) 
            S=SEQRDR.(SUBJECT) 
LOOK        TERM=SEQLR.(S,F) 
            Whenever F > 0, Transfer To FAIL 
            Whenever TOP.(TERM) = THEME, Transfer To FOUND 
            Transfer To LOOK 
FOUND       Transfer To DELTA(J) 
DELTA(1)    TPRINT.(TERM,0) 
            Transfer To CHANGE 
FAIL        PRINT COMMENT "LIST NOT FOUND" 
            Transfer To CHANGE 
DELTA(2)    S=SEQRDR.(TERM) 
            OLD=POPTOP.(INPUT) 
READ(1)     OBJCT=SEQLR.(S,F) 
            Whenever F > 0, Transfer To FAIL 
            Whenever F <> 0, Transfer To READ(1) 
            INSIDE=SEQRDR.(OBJECT) 
READ(2)     IT=SEQLR.(INSIDE,F) 
            Whenever F > 0, Transfer To READ(1) 
            SIT=SEQRDR.(IT) 
            SOLD=SEQRDR.(OLD) 
ITOLD       TOLD=SEQLR.(SOLD,FOLD) 
            DIT=SEQLR.(SIT,FIT) 
            Whenever TOLD = DIT AND FOLD <= 0,Transfer To ITOLD 
            Whenever FOLD > 0, Transfer To OK(J) 
            Transfer To READ(2) 
OK(2)       SUBST.(POPTOP.(INPUT),LSPNTR.(INSIDE)) 
            Transfer To CHANGE 
OK(3)       NEWBOT.(POPTOP.(INPUT),OBJCT) 
            Transfer To CHANGE 
DELTA(3)    Transfer To DELTA(2) 
DELTA(4)    Whenever NAMTST.(BOT.(TERM)) = 0 
                BOTTOM=POPBOT.(TERM) 
                NEWBOT.(POPTOP.(INPUT),TERM) 
                NEWBOT.(BOTTOM,TERM) 
            Otherwise 
                NEWBOT.(POPTOP.(INPUT),TERM) 
            End Conditional 
            Transfer To CHANGE 
DELTA(6)    S=SEQRDR.(TERM) 
READ(6)     OBJCT=SEQLR.(S,F) 
            Whenever F > 0, Transfer To FAIL 
            Whenever F <> 0, Transfer To READ(6) 
            OBJCT=SEQLL.(S,F) 
            Whenever LNKLL.(OBJECT) = 0 
                SUBST.(POPTOP.(INPUT),LSPNTR.(S)) 
            Otherwise 
                NEWTOP.(POPTOP.(INPUT),LSPNTR.(S)) 
            End Conditional 
            Transfer To CHANGE 
            End Function 

           R* * * * * * * * * * END OF MODIFICATION ROUTINE 

        TPRIN 
            EXTERNAL FUNCTION (LST) 
            NORMAL MODE IS INTEGER 
            ENTRY TO TPRINT. 
            SA=SEQRDR.(LST) 
            LIST.(OUT) 
READ        NEXT=SEQLR.(SA,FA) 
            Whenever FA > 0, Transfer To P 
            Whenever FA = 0, Transfer To B 
            POINT=NEWBOT.(NEXT,OUT) 
            Whenever SA < 0, MRKNEG.(POINT) 
            Transfer To READ 
B           TXTPRT.(OUT,0) 
            SEQLL.(SA,FA) 
MORE        NEXT=SEQLR.(SA,FA) 
            Whenever TOP.(NEXT) = "=" 
                TXTPRT.(NEXT,0) 
                Transfer To MORE 
            End Conditional 
            Whenever FA > 0, Transfer To DONE 
            PRINT COMMENT " " 
            SB=SEQRDR.(NEXT) 
MEHR        TERM=SEQLR.(SB,FB) 
            Whenever FB <0 
                PRINT ON LINE FORMAT NUMBER, TERM 
                Vector Values NUMBER = "I3 *" 
                Transfer To MEHR 
            End Conditional 
            Whenever FB > 0, Transfer To MORE 
            TXTPRT.(TERM,0) 
            Transfer To MEHR 
P           TXTPRT.(OUT,0) 
DONE        IRALST.(OUT) 
            Function Return 
            End Function 

        LPRIN 
            EXTERNAL FUNCTION (LST,TAPE) 
            NORMAL MODE IS INTEGER 
            ENTRY TO LPRINT. 
            BLANK = "      " 
            EXECUTE PLACE.(TAPE,0) 
            LEFTP = 606074606060K 
            RIGHTP= 606034606060K 
            BOTH  = 607460603460K 
            EXECUTE NEWTOP.(SEQRDR.(LST),LIST.(STACK)) 
            S=POPTOP.(STACK) 
BEGIN       EXECUTE PLACE.(LEFTP,1) 
NEXT        WORD=SEQLR.(S,FLAG) 
            Whenever FLAG < 0 
            EXECUTE PLACE.(WORD,1) 
            Whenever S > 0, PLACE.(BLANK,1) 
            Transfer To NEXT 
            OR Whenever FLAG > 0 
            EXECUTE PLACE.(RIGHTP,1) 
            Whenever LISTMT.(STACK) = 0, Transfer To DONE 
            S=POPTOP.(STACK) 
            Transfer To NEXT 
            OTHERWISE 
            Whenever LISTMT.(WORD) = 0 
            EXECUTE PLACE.(BOTH,1) 
            Transfer To NEXT 
            OTHERWISE 
            EXECUTE NEWTOP.(S,STACK) 
            S=SEQRDR.(WORD) 
            Transfer To BEGIN 
            End Conditional 
            End Conditional 
DONE        EXECUTE PLACE.(0,-1) 
            EXECUTE IRALST.(STACK) 
            FUNCTION RETURN LST 
            END OF FUNCTION 

        TESTS 
            EXTERNAL FUNCTION(CAND,S) 
            NORMAL MODE IS INTEGER 
            DIMENSION FIRST(5),SECOND(5) 
            ENTRY TO TESTS. 
            STORE=S 
            READER=SEQRDR.(CAND) 
            Through ONE, FOR I=0,1, I > 100 
            FIRST(I)=SEQLR.(READER,FR) 
ONE         Whenever READER > 0, Transfer To ENDONE 
ENDONE      SEQLL.(S,F) 
            Through TWO, FOR J=0,1, J > 100 
            SECOND(J)=SEQLR.(S,F) 
TWO         Whenever S > 0, Transfer To ENDTWO 
ENDTWO      Whenever I <> J, Function Return 0 
            Through LOOK, FOR K=0,1, K> J 
LOOK        Whenever FIRST(K) <> SECOND(K), Function Return 0 
            EQL=SEQLR.(READER,FR) 
            Whenever EQL <> "=" 
            SEQLL.(READER,FR) 
            Function Return READER 
            Otherwise 
            POINT=LNKL.(STORE) 
            Through DELETE , FOR K=0,1, K > J 
            REMOVE.(LSPNTR.(STORE)) 
DELETE      SEQLR.(STORE,F) 
INSRT       NEW=SEQLR.(READER,FR) 
            POINT=NEWTOP.(NEW,POINT) 
            MRKNEG.(POINT) 
            Whenever READER < 0, Transfer To INSRT 
            MRKPOS.(POINT) 
            Function Return READER 
            End Conditional 
            End Function 

        DOCBC 
            EXTERNAL FUNCTION (A,B) 
            NORMAL MODE IS INTEGER 
            ENTRY TO FRBCD. 
            Whenever LNKL.(A) = 0, Transfer To NUMBER 
            B=A 
            Function Return 0 
NUMBER      K=A*262144 
            B=BCDIT.(K) 
            Function Return 0 

            End Function 
        ELIZA 
            NORMAL MODE IS INTEGER 
            DIMENSION KEY(32),MYTRAN(4) 
            INITAS.(0) 
            PRINT COMMENT "WHICH SCRIPT DO YOU WISH TO PLAY" 
            READ FORMAT SNUMB,SCRIPT 
            LIST.(TEST) 
            LIST.(INPUT) 
            LIST.(OUTPUT) 
            LIST.(JUNK) 
            LIMIT=1 
            LSSCPY.(THREAD.(INPUT,SCRIPT),JUNK) 
            MTLIST.(INPUT) 
            Through MLST, FOR I=1,1, I > 4 
MLST        LIST.(MYTRAN(I)) 
            MINE=0 
            LIST.(MYLIST) 
            Through KEYLST, FOR I=0,1, 1 > 32 
KEYLST      LIST.(KEY(I)) 

           R* * * * * * * * * * READ NEW SCRIPT 

BEGIN       MTLIST.(INPUT) 
            NODLST.(INPUT) 
            LISTRD.(INPUT,SCRIPT) 
            Whenever LISTMT.(INPUT) = 0 
                TXTPRT.(JUNK,0) 
                MTLIST.(JUNK) 
                Transfer To START 
            End Conditional 
            Whenever TOP.(INPUT) = "NONE" 
                NEWTOP.(LSSCPY.(INPUT,LIST.(9)),KEY(32)) 
                Transfer To BEGIN 
               OR Whenever TOP.(INPUT) = "MEMORY" 
                POPTOP.(INPUT) 
                MEMORY=POPTOP.(INPUT) 
                Through MEM, FOR I=1,1, I > 4 
MEM             LSSCPY.(POPTOP.(INPUT),MYTRAN(I)) 
                Transfer To BEGIN 
               Otherwise 
                NEWBOT.(LSSCPY.(INPUT,LIST.(9)),KEY(HASH.(TOP.(INPUT),5))) 
                Transfer To BEGIN 
            End Conditional 

           R* * * * * * * * * * BEGIN MAJOR LOOP 

START       TREAD.(MTLIST.(INPUT),0) 
            KEYWRD=0 
            PREDNC=0 
            LIMIT=LIMIT+1 
            Whenever LIMIT = 5, LIMIT=1 
            Whenever LISTMT.(INPUT) = 0, Transfer To ENDPLA 
            IT=0 
            Whenever TOP.(INPUT) = "+" 
                CHANGE.(KEY,MYTRAN) 
                Transfer To START 
            End Conditional 
            Whenever TOP.(INPUT) = "*", Transfer To NEWLST 
            S=SEQRDR.(INPUT) 
NOTYET      Whenever S < 0 
                SEQLR.(S,F) 
                Transfer To NOTYET 
               Otherwise 
                WORD=SEQLR.(S,F) 
                Whenever WORD = "." OR WORD = "," OR WORD = "BUT" 
                    Whenever IT = 0 
                        NULSTL.(INPUT,LSPNTR.(S),JUNK) 
                        MTLIST.(JUNK) 
                        Transfer To NOTYET 
                       Otherwise 
                        NULSTR.(INPUT,LSPNTR.(S),JUNK) 
                        MTLIST.(JUNK) 
                        Transfer To ENDTXT 
                       End Conditional 
                    End Conditional 
                End Conditional 
                Whenever F > 0, Transfer To ENDTXT 
                I=HASH.(WORD,5) 
                SCANER=SEQRDR.(KEY(I)) 
                SF=0 
                Through SEARCH, FOR J=0,0, SF > 0 
                CAND= SEQLR.(SCANRE,SF) 
                Whenever SF > 0, Transfer To NOTYET 
SEARCH          Whenever TOP.(CAND) = WORD, Transfer To KEYFND 
KEYFND          READER=TESTS.(CAND,S) 
                Whenever READER = 0, Transfer To NOTYET 
                Whenever LSTNAM.(CAND) <> 0 
                    DL=LSTNAM.(CAND) 
SEQ                 Whenever S < 0 
                        SEQLR.(S,F) 
                        Transfer To SEQ 
                       Otherwise 
                        NEWTOP.(DL,LSPNTR.(S)) 
                    End Conditional 
                   Otherwise 
                End Conditional 
                NEXT=SEQLR.(READER,FR) 
                Whenever FR > 0, Transfer To NOTYET 
                Whenever IT = 0 AND FR = 0 
PLCKEY              IT=READER 
                    KEYWRD=WORD 
                   OR Whenever FR < 0 AND NEXT > PREDNC 
                    PREDNC=NEXT 
                    NEXT=SEQLR.(READER,FR) 
                    Transfer To PLCKEY 
                   Otherwise 
                    Transfer To NOTYET 
                End Conditional 
                Transfer To NOTYET 

               R* * * * * * * * * * END OF MAJOR LOOP 

ENDTXT          Whenever IT = 0 
                    Whenever LIMIT = 4 AND LISTMT.(MYLIST) <> 0 
                        OUT=POPTOP.(MYLIST) 
                        TXTPRT.(OUT,0) 
                        IRALST.(OUT) 
                        Transfer To START 
                       Otherwise 
                        ES=BOT.(TOP.(KEY(32))) 
                        Transfer To TRY 
                    End Conditional 
                   OR Whenever KEYWRD = MEMORY 
                    I=HASH.(BOT.(INPUT),2)+1 
                    NEWBOT.(REGEL.(MYTRAN(I),INPUT,LIST.(MINE)),MYLIST) 
                    SEQLL.(IT,FR) 
                    Transfer To MATCH 
                   Otherwise 
                    SEQLL.(IT,FR) 

               R* * * * * * * * * * MATCHING ROUTINE 

MATCH               ES=SEQLR.(IT,FR) 
                    Whenever TOP.(ES) = "=" 
                        S=SEQRDR.(ES) 
                        SEQLR.(S,F) 
                        WORD=SEQLR.(S,F) 
                        I=HASH.(WORD,5) 
                        SCANER=SEQRDR.(KEY(I)) 
SCAN                    ITS=SEQLR.(SCANER,F) 
                        Whenever F > 0, Transfer To NOMATCH(LIMIT) 
                        Whenever WORD = TOP.(ITS) 
                            S=SEQRDR.(ITS) 
SCANI                       ES=SEQLR.(S,F) 
                            Whenever F <> 0, Transfer To SCANI 
                            IT=S 
                            Transfer To TRY 
                        Otherwise 
                            Transfer To SCAN 
                        End Conditional 
                    End Conditional 
                    Whenever FR > 0, Transfer To NOMATCH(LIMIT) 

;;; A lot of the core work is done by the complex SLIP matching and
;;; rebuilding functions YMATCH and ASSMBL (see the latter at HIT)
;;; These are described on pages 62L28-29 of the SLIP manual:
;;;    https://drive.google.com/file/d/1XtF7EM1KhwMPKsp5t6F0gwN-8LsNDPOl

TRY                 Whenever YMATCH.(TOP.(ES),INPUT,MTLIST.(TEST)) = 0,Transfer To MATCH 
                    ESRDR=SEQRDR.(ES) 
                    SEQLR.(ESRDR,ESF) 
                    POINT=SEQLR.(ESRDR,ESF) 
                    POINTR=LSPNTR.(ESRDR) 
                    Whenever ESF = 0 
                        NEWBOT.(1,POINTR) 
                        TRANS=POINT 
                        Transfer To HIT 
                       Otherwise 
                        Through FNDHIT,FOR I=0,1, I > POINT 
FNDHIT                  TRANS=SEQLR.(ESRDR,ESF) 
                        Whenever ESF > 0 
                            SEQLR.(ESRDR,ESF) 
                            SEQLR.(ESRDR,ESF)                                   
                            TRANS=SEQLR.(ESRDR,ESF) 
                            SUBST.(1,POINTR) 
                            Transfer To HIT 
                           Otherwise 
                            SUBST.(POINT+1,POINTR) 
                            Transfer To HIT 
                        End Conditional 
                    End Conditional 
HIT                 TXTPRT.(ASSMBL.(TRANS,TEST,MTLIST.(OUTPUT)),0)  ;; See above, re SLIP functions YMATCH and ASSMBL
                    Transfer To START 
                End Conditional 

               R* * * * * * * * * * INSERT NEW KEYWORD LIST 

NEWLST          POPTOP.(INPUT) 
                NEWBOT.(LSSCPY.(INPUT,LIST.(9)),KEY(HASH.(TOP.(INPUT),5))) 
                Transfer To START 

               R* * * * * * * * * * DUMP REVISED SCRIPT 

ENDPLA          PRINT COMMENT "WHAT IS TO BE THE NUMBER OF THE NEW SCRIPT" 
                READ FORMAT SNUMB,SCRIPT 
                LPRINT.(INPUT,SCRIPT) 
                NEWTOP.(MEMORY,MTLIST.(OUTPUT)) 
                NEWTOP.("MEMORY",OUTPUT) 
                Through DUMP, FOR I=1,1 I > 4 
DUMP            NEWBOT.(MYTRAN(I),OUTPUT) 
                LPRINT.(OUTPUT,SCRIPT) 
                MTLIST.(OUTPUT) 
                Through WRITE, FOR I=0,1, I > 32 
POPMOR          Whenever LISTMT.(KEY(I)) = 0, Transfer To WRITE 
                LPRINT.(POPTOP.(KEY(I)),SCRIPT) 
                Transfer To POPMOR 
WRITE           CONTINUE 
                LPRINT.(MTLIST.(INPUT),SCRIPT) 
                EXIT. 

               R* * * * * * * * * * SCRIPT ERROR EXIT 

NOMATCH(1)      PRINT COMMENT "PLEASE CONTINUE " 
                Transfer To START 
NOMATCH(2)      PRINT COMMENT "HMMM " 
                Transfer To START 
NOMATCH(3)      PRINT COMMENT "GO ON , PLEASE " 
                Transfer To START 
NOMATCH(4)      PRINT COMMENT "I SEE " 
                Transfer To START 
                VECTOR VALUES SNUMB= "I3 * " 
                End of Program 

An excerpt from that site will serve to introduce this critique:

​Weizenbaum's ELIZA was intended as a general conversational agent. It interpreted a separate, domain-specific script that determined its style of conversation. The most well-known script is called "DOCTOR". This is the one that carries on the well-known "Rogerian therapist" conversations that appear in Weizenbaum's 1966 paper, and which are most commonly associated with the name "ELIZA." Indeed, the name "ELIZA" has basically come to mean “the ELIZA agent running the DOCTOR script.” ELIZA can be seen as the precursor of many of the conversation interfaces and chatbots that we have become so familiar with today, such as Siri, but it worked over a much more clunky typewriter-based console.

As Weizenbaum (1967: 475) explains, “From one point of view, an ELIZA script is a program and ELIZA itself an interpreter. From another perspective, ELIZA appears as an actor who must depend on a script for his [sic] lines. The script determines the contextual framework within which ELIZA may be expected to converse plausibly." In Contextual Understanding by Computers (CACM, 1967), he writes: "The first program to which I wish to call attention is a particular member of a family of programs which has come to be known as DOCTOR. The family name of these programs is ELIZA. This name was chosen because these programs, like the Eliza of Pygmalion fame, can be taught to speak increasingly well. DOCTOR causes ELIZA to respond roughly as would certain psychotherapists (Rogerians). ELIZA performs best when its human correspondent is initially instructed to "talk" to it, via the typewriter, of course, just as one would to a psychiatrist."

However, only the DOCTOR script appears in the 1966 paper, not the ELIZA code that interprets that script, although the algorithm is described in great detail. The common misconception that ELIZA was originally written in Lisp arose because shortly after the publication of the 1966 paper, Bernie Cosell wrote a version in Lisp, based upon the description of the algorithm in the 1966 paper. Cosell's version used a version of the published script, but he never saw the original ELIZA.

The language of the original ELIZA was MAD-SLIP. MAD (“Michigan Algorithm Decoder”) was an Algol-like programming language, available on many common large computers at that time. Weizenbaum added list-processing functionality to MAD, creating MAD-SLIP ("Symmetric LIst Processor," Weizenbaum, 1963), a Lisp-like language embedded in MAD. Indeed, adding to the Lisp/MAD-SLIP confusion, the published DOCTOR script, an appendix to the 1966 paper, is parenthesized exactly like a Lisp S-expression, the way one would if one were writing a Lisp program.** Here is a copy of the MAD-SLIP manual from a long, 3-volume 7090 user's guide.

We can probably work almost entire from the code transcript by Anthony Hay, which can be found [in this GitHub repo]. And it can be checked vs. [the original printout], as discovered in the MIT archives (also linked to the [the elizagen.org page]). I can also provide a high res copy upon request, although it's huge and page-by-page, and I don't think that it adds much more than can be seen on the lo-res printout, unless you are looking for traces of clam in the paper.

Further helpful resources are linked from [the elizagen.org page], including
[a SLIP manual], and [a primer on the MAD language]. I am trying to invite experts on both MAD and SLIP to the conversation. Mark and Jeremy have partially OCR/xscribed the SLIP manual, but it's difficult. If folks decide it's necessary, we were thinking of crowdsourcing that among those participating in this thread.

Here are some Preliminary discussion questions:

1. What does the SLIP code tell us about the functioning of ELIZA?
2. How does Weizenbaum take advantage of SLIP’s features? (Note that he wrote SLIP, originally as an add-on to Fortran, and then MAD.)
3. In what way does the DOCTOR script make use of the affordances of this code?
4. Does the DOCTOR script merely use or complete this system?
5. In what way does this code set up a system for a variety of scripts?
6. What does this code tell us about the affordances or limitations of SLIP?
7. How does MAD-SLIP facilitate or inhibit the creation of ELIZA and DOCTOR?

And some more ELIZA-related questions:
1. How (well) does/did ELIZA implement a "talking cure"?
2. What signs of ELIZA’s heritage can be seen in contemporary conversational interfaces, such as Siri, Alexa, [ALICE], and perhaps especially [woebot]? (One might recall [the famous transcript of a discussion between ELIZA and PARRY], an ELIZA knock-off that simulated a paranoid patient.)
3. The code appears to have a "teaching" mode that allows the interlocutor to teach ELIZA new responses. This has, so far as I know, never been significantly commented upon in discussions of ELIZA. Does this change the way we think of Weizenbaum's project?

In excited anticipation; Your humble co-discussion-leader,
'Jeff

In 1994, Bethesda Softworks released Arena, a computer roleplaying game with a large world full of procedurally generated characters and locations. The content generation included creating culturally appropriate names for people that you meet. These names would be given when you talk to them, like so:

Each of the names would be generated according to different sets of rules. For the European-inspired fantasy races (Bretons, Nords, Imperials), these would involve simple combination of a prefix and suffix. For example, the male Bretons names have 169 variations, each comprised of a combination of one of 13 suffixes and 13 prefixes:

The 13 prefixes for male Breton names are: Agr-, Alab-, And-, Bed-, Dun-, Edw-, Gond-, Mord-, Per-, Rod-, Theod-, Trist-, and Uth-.
The 13 suffixes for male Breton names are: -ane, -ard, -astyr, -istair, -istyr, -ore, -oryan, -yctor, -yn, -ynak, -yrick, -yval, and -ywyr.

This would be guaranteed to lead to comprehendible fantasy names like "Alabard", Theodyrick", or "Peryn". However, for the Redguard race, the algorithm for generating names is a bit more complicated. Here is the code for generating names as recreated for Daggerfall Unity. This is a project that recreates Daggerfall, which is the sequel to Arena. It faithfully uses the same set of rules and word list as the original Arena.

 // Gets random Redguard name which follows 0+1+2+3(75%) (male), 0+1+2+4 (female) pattern
        string GetRandomRedguardName(NameBank nameBank, Genders gender)
        {
            // Get set parts
            string[] partsA, partsB, partsC, partsD;
            if (gender == Genders.Male)
            {
                partsA = nameBank.sets[0].parts;
                partsB = nameBank.sets[1].parts;
                partsC = nameBank.sets[2].parts;
                partsD = nameBank.sets[3].parts;
            }
            else
            {
                partsA = nameBank.sets[0].parts;
                partsB = nameBank.sets[1].parts;
                partsC = nameBank.sets[2].parts;
                partsD = nameBank.sets[4].parts;
            }

            // Generate strings
            uint index = DFRandom.rand() % (uint)partsA.Length;
            string stringA = partsA[index];

            index = DFRandom.rand() % (uint)partsB.Length;
            string stringB = partsB[index];

            index = DFRandom.rand() % (uint)partsC.Length;
            string stringC = partsC[index];

            string stringD = string.Empty;
            if (gender == Genders.Female || (DFRandom.rand() % 100 < 75))
            {
                index = DFRandom.rand() % (uint)partsD.Length;
                stringD = partsD[index];
            }

            return stringA + stringB + stringC + stringD;
        }

The strings referred to here can be seen in this file. The code works as described on the unofficial Elder Scrolls wiki:

Names for male Redguards in Arena consist of a prefix followed by a vowel followed by a consonant, sometimes followed by a suffix. Redguards have no surnames.
The 43 prefixes for male Redguard names are: B, Ba, Bl, Br, C, Ca, Ch, Cr, D, Dh, F, Fh, Fl, Fr, G, Gh, Gl, Gr, K, Kh, Kl, Kr, L, Lh, M, Ma, Mh, N, Nh, R, Rh, Rl, S, Sa, Sh, Shr, Sl, St, T, Th, Tl, V, Vl
The 5 vowels for male Redguard names are: a, e, i, o, u
The 15 consonants for male Redguard names are: b, c, d, h, j, k, l, m, n, p, r, s, t, v, z
The 22 suffixes for male Redguard names are: am, an, ar, e, em, en, er, im, in, ir, ke, 'kern, om, on, rn, t, ta, te, ten, um, un, ur

The Redguards, in their appearance, dress and architecture, are clearly inspired to an extent by Arabic and North African cultures. However, in attempting to make a generator that generates legible and 'Redguard-sounding' names, among the many possible names are several which have absurd or offensive meanings in English and other languages.

For example, this character's name is particularly apt in Portuguese:

Following the algorithm (picking from the lists in order: a prefix, a vowel, a consonant and then optionally a suffix), you can easily form a number of words that wouldn't be appropriate to label someone, including racial epithets or words close to them.

Given the huge range of possible names (74,175 male names), it's quite possible most players wouldn't see anything untoward, though some would. After all, the screenshot above was from my own playthrough, the seventh person I spoke to.

What would have been a more anti-racist way of procedurally generating fantasy names?

In later instalments of the series, certain Redguard name suffixes and prefixes took on a specific meaning, inspired by Arabic naming conventions. Instead of stringing together non-meaningful combinations of letters, they could have alternatively taken the approach of using larger name components, as seen with many of the other cultures names in the game.

And should projects that seek to recreate and restore old games, like Daggerfall Unity, reproduce code that can produce derogatory and racist names?

“Kubectl” or “Kube Control” is the command-line interface for Kubernetes, or K8S, the server orchestration framework originally developed by Google. It is used to manage software principally in the cloud, where it can scale up software applications based upon a specification or manifest, as well as via monitoring the live expenditure of computing resources. The command-line interface works on top of these deployment definitions, much like the Unix command-line allows a user to interrogate the state of a runtime system.

K8S’ name and its history at Google are problematic though: “Kubernetes” is the root word or variant of the root from which we get the "Cybernetics" of Norbert Wiener, and an early name of the platform was "Borg", based upon the Star Trek aliens who assimilate/colonize other alien civilizations and boldly announce to them that "resistance is futile”. In addition, the architecture of the platform demarcates "master" nodes that run within a "control pane" and "worker nodes" that host applications and run them. The fundamental unit of the nodes is the “pod,” which is a collection of application container environments running code. Especially with the name of the command-line interface suffixed with -ctl, which is an abbreviation for “control” the K8S platform seems to be a direct embrace of the discipline of cybernetics as “command and control”.

That said, K8S is powerful, and could be seen to facilitate exploratory programming, coding ateliers, and Marxian dreams of allowing proletarian developers to instantly instantiate a technological and productive base that determines how political and cultural bodies are represented. In particular, two powerful features of Kubernetes/kubectl are namespaces and labels, allowing a developer to organize/orchestrate server resources, as the so-called helmsperson.

Labels more specifically allow search-engine-like queries on these resources, so that a developer could summon all components running their app via just a few commands—despite the fact that this app would be built from nodes of worker pods in a vast homogeneous sea of other worker pods.

For example, labels can be used to group pods by application name or release type as demonstrated by Marko Lukša in his Manning guide to K8S, but the labels can be anything. With kubectl, I can create a YAML manifest:



apiVersion: v1
kind: Pod
metadata:
    name: myApp-cloud-001 
        labels: 
            app: picturebook 
            rel: beta    
spec:
    containers:
    
    - name: myApp-Container 
        image:  myApp-w-nodeJS
        
            ports:
        
            - containerPort: 8080 
... 

And I then can create a cloud cluster, replicating nodes with pods by passing the manifest file above as an argument:

kubectl apply -f pod.myapp.yaml



And then, after K8S has spun up my app and distributed it potentially to multiple pods all automatically, I can summon these pods with a command like the following, specifying which ones I want to fetch via the labels I've defined:



kubectl get po -L app,rel

Or:

kubectl get pods -l app=taxes, rel=beta

Or another query using kubectl:

kubectl get pods -l 'app in (picturebook, taxes)' -L app

These searchable labels exemplify inaugural Cybernetics, as “labelling” has been at the center of development of programming after World War II—whenever we speak of variables, identifiers, keywords and code. Because first generation cybernetics formalizes symbolic language within the same cultural and disciplinary space as Lacanian psychoanalysis, so a kubectl label is a use of language becoming absolute and formal and integrated into societal controls. In fact, K8S labels embody applied programming, but also command and control, since the entire lifecycle of their applications is automated through selectors (like in the queries above) on these labels. Note too that, scaling up, scaling down, and restarting pods and containers, a given application never terminates—in true Borg fashion.

At the birth of the Unix computer, if a command to list the file contents of a single computer made the human-computer interface operative, so kubectl has multiplied this system interrogation for thousands of machines simultaneously—as one giant distributed machine. The “power” of the command-line is propagated to kubectl, which can also wrap the operating system command-line in serverless instructions that produce a command result while bypassing runtime systems altogether in some cases**. In effect, in the figure of the software platform K8S, the metaphor of command and control in its specific post-war flavor has been resurrected. But there are many hidden costs of this magic-seeming orchestration across thousands of machines, whether environmental or related to the denial of death and materiality.

As a result, the wealth of critiques of cybernetics, even those from its own age, must be applied to cloud computing. Deleuze and Guattari are helpful here, in offering better metaphors for technology: the notion of the machinic is a critique of the Lacanian signifier-signified relation assumed by the Western labelling subject—while not abandoning technological metaphors. Gilbert Simondon’s work is relevant here too: in the notions of individuation and mechanology, value of technological artifacts in their “aseity” is deferred until interested actors, readers, and cultural laborers productively articulate their interconnections.

As it turns out, one of the lesser known features of K8S is what is called its affinity and anti-affinity definitions, which can be added to a deployment specification or manifest. An affinity definition is a set of numeric values that specify the probability of hardware and system conditions by which containers and pods should group themselves together and reform pod instances when one or more of them has been temporarily terminated to be replaced by other pods. No doubt, this feature is a tool of automation still ultimately tied to command and control. But could the general notion of affinity rather than a helmsperson offer a way out of current K8S metaphors?

Questions

1. What should Kubernetes/kubectl be called instead? :-)
2. What would Kubernetes look like if it were built from the ground up on affinities, which would be its raison d’être? What if corporate technology were forced to build its systems on “affinity machines”?
3. What are some ways “always running” systems are problematic? Does Kubernetes enforce a status quo in its highly programmatically deterministic specifications and manifests?

** For example, a command to look up a DNS setting on a resource:
kubectl run -it srvlookup --image=tutum/dnsutils --rm --restart=Never -- dig SRV taxes.default.svc.cluster.local, after Lukša.
The rm removes the server image, but the command still produces an output.

/*
v. 3.57
31.07.11
PTRACE.PAS (c't 1 / 93,167ff.) Extended
Super ellipsoid, rotational body and procedural textures from povray3
DOS version no longer supported

compile:
Normal: xgraf xsuptrace ray.s matrices.s
// Option -DNEWFRESNEL: simplified Fresnel light from povray3
Option -DJITTER: fuzzy (and time-consuming) shadows
Option -DGAMMA: gamma correction
SVGALIB or DGA: picture.i ".equ XWINDOW, 1" change!

RUNTIME:
<xsuptrace 1>: reproducible noise for runtime tests

FEATURES:
All reflective surfaces can be switched to ReflectionMapping: what
then appears on its surface is a picture to be loaded. This feature
But users have to demand standard interfaces first.

Prompts (':') for scalars and vectors can be defined either with <w [eiter]>
or <n [on]> acknowledge or answer with a new input

3 constant objects: sky, hell, ground (which only allows plein-air images)
Any number of variable objects (limited only by memory)
As variable objects by default 2 balls and 1 other object each predefined
ned. But standard objects can be deleted again.
If more than the standard number is required by an object, inquire
Prompt the new coordinates.
All objects editable (constant only by reassignment of color to normal)
procedure, variable also by location and size).
Some exotic objects are scalable and rotatable. This will be expanded.
Any number of lamps, the first 2 predefined.
Surfaces 1. global, 2. individually assignable after assignment to objects.
LINUX: any size * .24f images can be loaded as 2D textures.

Objects as a ring list for faster intershade () (see Foley, p.
Lamps as a simply linked list.
Left-hand coordinate system: left <x <right, front <y <behind,
below <z <above.

NEW:
01.04.97: AttCol () - acceleration away - transparencies would be worse
07.04.98: individual Fresnel coefficients with individual dullness for
opaque, but metallic surfaces (so these coefficients TransC and
to overwrite the dullness transparently). That's physically correct
and, mirabile dictu, better than POVRAY3. Color charts (ColTabT) global
edierbar
Nov. 22, 1998: ReflV () after Glassner, Image Synthesis, p. 726, again in
Light () calculated per lamp
24.12.98: Object slice selectable; Unzipped DOS - *. 24f files are loadable
08.03.99: Experimental support for Ohta / Maekawa algorithm
01.09.01: DOS no longer supported
13.08.04: Init_Ohta () different, untested
24.10.08: Steel new to /usr/ich/laptop/xsuptrace.c

BUGS:
Spheres of stei, sup, sor determined very empirically
2DMapping on Steiner, Agnesi, SuperQuadrik and Drehkoerper only as a reflection
Map implements: the transformation (x, y, z) -> (u, v) would be hard
MapProc () and Init_Fresnel () are not prepared for multiple calls from xsuptrace
Editing boxes and pyramids still uneven
lambda and thin globally, not variable per surface
No transparency shading as in CALCNEW.C
For floating objects, NULL pointer errors are inevitable; you
Change a midpoint coordinate to small amounts
SOR orb is detected in Edit_Sor () instead of Gravity ()
Refractive indices do not depend on wavelengths of light
08.04.99: intershade () returns L-> Shad correctly, but the object cohesion
breaks again and again, slows down more
30.12.00: xgraf (gcc with optimization) can falsify the SOR curve if
in SorInput the difference quotient Dy / Dx (ie the slope between
two x fixed points) becomes too large.
09.09.03: Changes to transformation matrices only apply to gcc -g. dark
31.07.11: QuColProc () dare

HINTS:
Between internal data structures and user displays, complex conversion
take place; So do not patch global data!
*/

#define  SUPTRACE
#define  COLTABSIZE   127       // unter DOS ggf. kleiner     
#define  PIII                   // bei schlechterer CPU dringend aendern!

// CompileTime: Globale Zaehler, bei neuen Objekten oder Oberflaechen erhoehen

#define SurfCnt       27        
#define FormCnt       16

#include <time.h>
#define  SPALTEN 640
#define  ZEILEN  480
#define  RAY
#include "xdefines.h"   // SVGALIB: defines.h 
#include "ray.h"        // SVGALIB: #include bild16m.c || lock16m.c 

extern float Infinit,halb,Epsilon;
VCT3  lambda = { 52.36, 56.6, 68.313 };
float duenne = 0.35, LampDiv = 1.;

// RunTime: Zaehler je Sitzung 
int ObjCnt  = 0;
int RingCnt = 0;
int LampCnt = 0;
int FormCnts[FormCnt] = {0};
int TestFormCnt = FormCnt-1;

#ifdef JITTER
float circle[19][2] = {
  {0.75, 0.433}, { 0.0,0.866},   {-0.75,0.433},{-0.75,-0.433 },{0.0,-0.866 },
  {0.75,-0.433}, { 0.0,0.0  },   { 0.75,0.0  },{0.375, 0.65  },{-0.375,0.65},
  {-0.75,0.0  }, {-0.375,-0.65}, {0.375,-0.65},{0.375,0.216  },{0.0,0.433  },
  {-0.375,0.217},{-0.375,-0.216},{0.0,-0.433 },{0.375,-0.217}};
float jitter_offset = 0.75/((float)RAND_MAX);
#endif

// global, um Debuggen und Fehler() zu erlauben
static uint x,y,RDepth = 0;
// global wegen ray.s
VCTd4  dquart;          
VCT4   quart;
VCT6   bicub;

#ifdef OHTA
typedef struct { VCT3 dist; float costheta; } dirT;
dirT    **direction;
int     lastring;
#endif

int   normal[FormCnt] = {0,1,4,7,2,11,10,7,6,11,3,14,12,5,2,23};
char  ObjStr[FormCnt][32] = {
  "den Himmel          ",
  "die Hoelle          ",
  "den Boden           ",
  "eine Kugel          ",
  "ein Moebiusband     ",
  "eine Steinerflaeche ",
  "einen Torus         ",
  "ein Ellipsoid       ",
  "einen Kegel         ",
  "eine Pyramide       ",
  "einen Quader        ",
  "eine Agnesi         ",             
  "ein Superellipsoid  ",
  "Rotationskoerper    ",
  "eine Scheibe        ",
  "eine Lemniskate     "
  };

FrameT Frame = {
  { 2.0, -8.0, 0.992},  // eye          
  { 0.1,  0.1, 0.1 },   // Ambient   
    0.96, 17,  5, 
    0.01, 0.0,          // AttenEps unbenutzt 
  { 0.50, 0.5, 0.6}, 0};// Fog_Color, Fog 

LampT *Lampen = NULL;
Prims *Boden,*Hoelle,*Himmel,*Ring,*Last;
int   arg = TRUE;

// VORDEFINIERTE OBJEKTE 

kugelT k1   =  {
  { 2.5, -2.7, 1.0 }, 1.0 };

kugelT k2   =  {
  {-0.2, -4.0, 1.3 }, 1.15 };

steiT  stei =  {
  {-2.0, -5.0, 1.0},
  { 1.0,  1.0, 1.0}};

moeT   moeb =  {
  {{ 2.4, 0.5, 4.0 }, 1.4 }, 
  0.25, 1 }; 

torT   tor  =  {
  { 2.9,-5.5, 0.6}, 0.3, 0.1 };

ellT   ell  =  {
  {3.8, -3.9, 1.4 },
  {0.3, -0.2, 0.6 },
  {0,0,0,0,0,0,0,0,0,0}};

coneT cone =  {
  {{ 1.4,-4.5,1.6 }, 0.29146 },
  0.3, 1.4, 0,1,20 }; 

pyrT pyr = {
  {{ 3,4,
  { 1.0, 1.0, 1.0 },    // LINKS - normal
    {{-0.9,-1.3, 2.2 }, // links 
    { 0.4,-2.5, 2.6 },  // Mitte 
    { 0.1,-0.5, 4.2 }}},// oben  
  { 3,4,
    { 1.0, 1.0, 1.0 },  // RECHTS 
    {{ 0.4,-2.5, 2.6 }, // Mitte  
     { 1.3, 0.2, 2.2 }, // rechts 
     { 0.1,-0.5, 4.2 }}},// oben   
  { 3,4,
    { 1.0, 1.0, 1.0 },   // UNTEN  
    {{ 1.3, 0.2, 2.2 },  // rechts 
    { 0.4,-2.5, 2.6 },   // Mitte  
    {-0.9,-1.3, 2.2 }}}, // links  
  { 3,4,
    { 1.0, 1.0, 1.0 },   // HINTEN 
    {{ 0.1,-0.5, 4.2 },  // oben   
    { 1.3, 0.2, 2.2 },   // rechts 
    {-0.9,-1.3, 2.2 }}}},// links  
  0, 0 };                // Polygon,dummy 

agnT agn = {{{-7.3,0.5,3.5},3.}, {-20, 0, 0}, 1.1 };

BoxInput B1 = { -1,1,3.0,1.5,-1,1 };

boxT box1; 

superT sup = {{ -1.5,-1.5,2.4 }, {2.0/0.7,0.7/0.6,2.0/0.6}, 
  {{-1,-1,-1},{1,1,1}},{1,1,1}};

sorInput sorI = {
  7,TRUE,
  {{ 1.80000,-0.100000},
    { 0.118143,0.020000},
  { 0.620253,0.540084},
    { 0.210970,0.827004},
    { 0.194093,0.962025},
  { 0.286920,1.035000},
    { 0.488354,1.150000}}};

discT scheibe = {{{ -1, 2, 2.7 }, 1.8 }, {0.4,-0.8,0.55}, 1, 0.7 };

lemniT lemnis = {{{ 4.1, -0.8, 1.85 }, 1.3 }, { 90., 0., 0. }};

// Vordefinierte Lampen 

LampT L1 = {
  {  4.0, -3.5, 4.5 },
  {  0.95, 0.8, 0.8 },
  {  1.0,  1.0, 1.0 },   
    0.6, NULL, NULL };
LampT L2 = {
  { -2.0, -3.5, 1.5 },  
  {  0.9,  0.9, 1.0 },
  {  1.0,  1.0, 1.0 },
    0.3, NULL, NULL };

// TEXTUREN 

uchar Lattice[LatCnt][LatCnt][LatCnt];

typedef struct { int Nr; VCT3 c; } ColTabT;
typedef VCT3 ColList[COLTABSIZE+1];

ColList HellTab   = {{ 0,0,0 }};
ColList FlameTab  = {{ 0,0,0 }};
ColList MarbleTab = {{ 0,0,0 }};

ColTabT MarbleCols[4]  = {
  {  0, { 0.41,0.25,0.15}},
  { 36, { 0.20,0.43,0.55}},
  { 66, { 0.91,0.93,0.88}},
  {127, { 0.64,0.66,0.55}}};

ColTabT HellCols[4]  = {
  {  0, { 0.7, 0.2, 0.1}},
  { 30, { 0.5, 0.8, 0.2}},
  { 60, { 0.9, 0.7, 1.0}},
  {127, { 0.7, 0.4, 0.0}}}; 

ColTabT FlameCols[6] = {
  {  0, { 1.00,1.00,1.00}},
  { 59, { 0.99,0.77,0.42}},
  { 63, { 0.75,0.80,0.51}},
  { 88, { 0.90,0.59,0.34}}, 
  {108, { 0.69,0.38,0.30}},
  {127, { 0.12,0.19,0.54}}}; 

#include "surfaces.h"

float  h,v;

/*
#ifdef DEBUG
VCT3   c;
ulong  nr_of_rays = 0; // 1199073 
ulong  nr_of_refl = 0; //  574234 
ulong  nr_of_refr = 0; //  438160 
ulong  nr_of_coh  = 0; //   66893
ulong  nr_of_rest = 0; //   42195
#endif
*/

void 
Translate_Object (Prims *Obj, VCT3 *t)
{
  TransformT trans;
  Compute_Translation_Transform (&trans, t);
  Compose_Transforms (&Obj->transform, &trans);
}

void 
Scale_Object (Prims *Obj, VCT3 *s)
{
  TransformT trans;
  Compute_Scaling_Transform (&trans, s);
  Compose_Transforms (&Obj->transform, &trans);
}

void 
Rotate_Object (Prims *Obj, VCT3 *r)
{
  TransformT trans;
  Compute_Rotation_Transform (&trans, r);
  Compose_Transforms (&Obj->transform, &trans);
}

void 
Fehler(void)
{
  blau();
  printf("%c%s",7,"Nullvektor!\n");
  printf("Spalte: %d, Zeile: %d, Tiefe: %d\n",x,y,RDepth);
  exit(1);
}

// RAYTRACER-ZUSATZ-FUNKTIONEN 

void 
FogProc (VCT3 *p,VCT3 *c)
{
  float factor;

  if ((factor = exp(-vdist(p,&Frame.eye)/Frame.Fog_Distance)) < 0.2)
    factor = 0.2;
  factor += 0.1 * turbulence(p);
  c->x = (c->x - Frame.Fog_Color.x) * factor + Frame.Fog_Color.x;
  c->y = (c->y - Frame.Fog_Color.y) * factor + Frame.Fog_Color.y;
  c->z = (c->z - Frame.Fog_Color.z) * factor + Frame.Fog_Color.z;
}

void    
Gravity(Prims *Obj) // ermittelt Schwerpunkt und von daher Umkugel 
{
  float  r,s,t;
  ellT   *ep;
  torT   *tp;
  moeT   *mp;  
  coneT  *cp;
  pyrT   *pp;
  steiT  *sp;
  agnT   *ap;
  boxT   *bp;
  superT *up;
  discT  *dp;
  lemniT *lp;
  int   i,j,ganz;             
  VCT3  d[2];

  switch(Obj->form)
  {
  case moebius:
    mp = Obj->UU.moeptr;
    r  = halb * mp->hoch * mp->hoch * (1 - M_SQRT_2);
    Obj->umkugel = mp->ax;
    Obj->umkugel.m.x += r;
    Obj->umkugel.m.y += r;
    Obj->umkugel.rad += mp->hoch * 2; 
    break;  
  case steiner:
    sp = Obj->UU.steiptr;
    Obj->umkugel.m = sp->m;
    r = fabs(sp->ax.x);
    s = fabs(sp->ax.y);
    Obj->umkugel.rad = t = fabs(sp->ax.z);
    if (r > s)
      {
      if (r > t)
        Obj->umkugel.rad = r;
      }
    else
      {
      if (s > t)
        Obj->umkugel.rad = s;
      }
    break;
  case torus:
    tp = Obj->UU.torptr;
    Obj->umkugel.m = tp->m;
    Obj->umkugel.rad = tp->a + tp->b;
    tp->a *= tp->a;
    tp->b *= tp->b;
    break;
  case ellipsoid:
    ep = Obj->UU.ellptr;
    ep->mat.a = r = 1./(ep->ax.x * ep->ax.x);
    ep->mat.e = s = 1./(ep->ax.y * ep->ax.y);
    ep->mat.h = t = 1./(ep->ax.z * ep->ax.z); // Hyperboloid = -h
    ep->mat.d = -ep->m.x*r;
    ep->mat.g = -ep->m.y*s;
    ep->mat.i = -ep->m.z*t;     // Hyperboloid = -i 
    ep->mat.j = (ep->m.x*ep->m.x*r + ep->m.y*ep->m.y*s
      + ep->m.z*ep->m.z*t)-1;
    Obj->umkugel.m = ep->m;
    r = fabs(ep->ax.x);
    s = fabs(ep->ax.y);
    Obj->umkugel.rad = t = fabs(ep->ax.z);
    if (r > s)
      {
      if (r > t)
        Obj->umkugel.rad = r;
      }
    else
      {
      if (s > t)
        Obj->umkugel.rad = s;
      }
    break;
  case kegel:
    cp = Obj->UU.coneptr;
    r  = cp->apex.rad * cp->apex.rad;
    Obj->umkugel.m = cp->apex.m;
    Obj->umkugel.m.z = halb*(r+1) * (cp->high+cp->low) - r * cp->apex.m.z;
    Obj->umkugel.rad = r * (cp->apex.m.z-cp->high) * (cp->apex.m.z-cp->high) 
      + (cp->high-Obj->umkugel.m.z) * (cp->high-Obj->umkugel.m.z);
    Obj->umkugel.rad = sqrt(Obj->umkugel.rad);
    break;
  case pyramide: 
    pp = Obj->UU.pyrptr;
    pp->planes = 4;
    for (i = 0; i < 4; i++)
      {
      pp->flaechen[i].vertnum = 3;
      pp->flaechen[i].polynum = 4;
      }
    ganz = pp->flaechen[0].vertnum * pp->planes;
    Obj->umkugel.rad = 0;
    Obj->umkugel.m.x = Obj->umkugel.m.y = Obj->umkugel.m.z = 0;
    for (i = 0; i < pp->planes; i++)
      for (j = 0; j < pp->flaechen[i].vertnum; j++)
        vaddeq(&Obj->umkugel.m,&pp->flaechen[i].vtx[j]);
    vscaleeq(&Obj->umkugel.m,1./(float)ganz);
    for (i = 0; i < pp->planes; i++)
      for (j = 0; j < pp->flaechen[i].vertnum; j++)
        if ((r = vdist(&Obj->umkugel.m,&pp->flaechen[i].vtx[j])) 
          > Obj->umkugel.rad)
         Obj->umkugel.rad = r;
    for (i = 0; i < pp->planes; i++)
      {
      vsub(d,&pp->flaechen[i].vtx[1],&pp->flaechen[i].vtx[0]);
      vsub(&d[1],&pp->flaechen[i].vtx[2],&pp->flaechen[i].vtx[1]);
      vcross(&pp->flaechen[i].normal,d,&d[1]);
      normalize(&pp->flaechen[i].normal);
      vsubnorm(d,&pp->flaechen[i].vtx[0],&Obj->umkugel.m);
      // gegen falsche Reihenfolge von Polygonecken-Eingaben
      negnorm(d,&pp->flaechen[i].normal);
      }
    break;
  case box:
    bp = Obj->UU.boxptr;
    bp->planes = 6;
    for (i = 0; i < 6; i++)
      {
      bp->flaechen[i].vertnum = 4;
      bp->flaechen[i].polynum = 6;    
      } 
    ganz = bp->flaechen[0].vertnum * bp->planes;
    Obj->umkugel.rad = 0;
    Obj->umkugel.m.x = Obj->umkugel.m.y = Obj->umkugel.m.z = 0;
    for (i = 0; i < bp->planes; i++)
       for (j = 0; j < bp->flaechen[i].vertnum; j++)
        vaddeq(&Obj->umkugel.m,&bp->flaechen[i].vtx[j]);
    vscaleeq(&Obj->umkugel.m,1./(float)ganz);
    for (i = 0; i < bp->planes; i++)
      for (j = 0; j < bp->flaechen[i].vertnum; j++)
        if ((r = vdist(&Obj->umkugel.m,&bp->flaechen[i].vtx[j]))
          > Obj->umkugel.rad)
          Obj->umkugel.rad = r;
    for (i = 0; i < bp->planes; i++)
      {
      vsub(d,&bp->flaechen[i].vtx[1],&bp->flaechen[i].vtx[0]);
      vsub(&d[1],&bp->flaechen[i].vtx[2],&bp->flaechen[i].vtx[1]);
      vcross(&bp->flaechen[i].normal,d,&d[1]);
      normalize(&bp->flaechen[i].normal);
      vsubnorm(d,&bp->flaechen[i].vtx[0],&Obj->umkugel.m);
      // gegen falsche Reihenfolge von Polygonecken-Eingaben 
      negnorm(d,&bp->flaechen[i].normal);
      }
    break;
  case agnesi:
    ap = Obj->UU.agnptr;
    Obj->umkugel.m = ap->ax.m;
    Obj->umkugel.rad = ap->scale*1.2;
    Create_Transform (&Obj->transform);
    Rotate_Object (Obj,&ap->rotate);
    d[0].x = d[0].y = d[0].z = ap->scale;
    Scale_Object(Obj,d);
    Translate_Object (Obj,&ap->ax.m);
    break;
  case super:
    up = Obj->UU.supptr;
    Obj->umkugel.m = up->m;
    if (up->scal.x > up->scal.y)
      {
      if (up->scal.x > up->scal.z)
        Obj->umkugel.rad = up->scal.x;
      else
        Obj->umkugel.rad = up->scal.z;
      }  
    else
      {
      if (up->scal.y > up->scal.z)
        Obj->umkugel.rad = up->scal.y;
      else
        Obj->umkugel.rad = up->scal.z;
      }
    Obj->umkugel.rad *= 1.7;   // groesser als theoretisches sqrt(2) 
    Create_Transform (&Obj->transform);
    Scale_Object (Obj,&up->scal);
    Translate_Object (Obj, &up->m); 
    break;
  case disc:
    dp = Obj->UU.discptr;
    Obj->umkugel = dp->ax;
    normalize (&dp->normal);
    dp->d = -vdot(&dp->ax.m,&dp->normal);   // v.Mangold, I,430  
    break;
  case lemni:
    lp = Obj->UU.lemniptr;
    Obj->umkugel = lp->ax;
    Create_Transform (&Obj->transform);
    Rotate_Object(Obj,&lp->rotate);       
    Translate_Object(Obj,&lp->ax.m);
    break;   
  default: ;
  }
}

// Spezielle Schnittpunkt-Routinen 

#define DEPTH_TOLERANCE 1.0e-3  // double 1.0E-4  
#define ZERO_TOLERANCE  1.0e-4  // double 1.0E-10 
#define SGNX(x) (((x) >= 0.) ? 1 : -1)
#define MAX_ITERATIONS  20
#define PLANECOUNT      9

static float planes[PLANECOUNT][4] =
   {{1, 1, 0, 0}, {1,-1, 0, 0},
    {1, 0, 1, 0}, {1, 0,-1, 0},
    {0, 1, 1, 0}, {0, 1,-1, 0},
    {1, 0, 0, 0}, {0, 1, 0, 0},
    {0, 0, 1, 0}};

char 
intersect_box (VCT3 *P, VCT3 *D, float *dmin, float *dmax)
{
  float tmin,tmax;

  // Links/rechts 
  if (fabs (D->x) > Epsilon)
    {
    if (D->x > Epsilon)
      {
      if ((*dmax = (1-P->x) / D->x) < Epsilon)
        return FALSE;
      *dmin = (-1-P->x) / D->x;
      }
    else
      {
      if ((*dmax = (-1-P->x) / D->x) < Epsilon)
        return FALSE;
      *dmin = (1-P->x) / D->x;
      }
    if (*dmin > *dmax) 
      return FALSE;
    }
  else
    {
    if (fabs(P->x) > 1)
      return FALSE;
    *dmin = -Infinit;
    *dmax =  Infinit;
    }
  tmin = tmax = 0.;
  // Oben/unten 
  if (fabs (D->y) > Epsilon)
    {
    if (D->y > Epsilon)
      {
      tmin = (-1-P->y) / D->y;
      tmax = (1-P->y) / D->y;
      }
    else
      {
      tmax = (-1-P->y) / D->y;
      tmin = (1-P->y) / D->y;
      }
    if (tmax < *dmax)
      {
      if (tmax < Epsilon) 
        return FALSE;
      if (tmin > *dmin)
        {
        if (tmin > tmax) 
          return FALSE;
        *dmin = tmin;
        }
      else
        {
        if (*dmin > tmax)
          return FALSE;
        }
      *dmax = tmax;
      }
    else
      {
      if (tmin > *dmin)
        {
        if (tmin > *dmax) 
          return FALSE;
        *dmin = tmin;
        }
      }
    }
  else
    {
    if (fabs(P->y) > 1)
      return FALSE;
    }
  // Vorn/hinten 
  if (fabs (D->z) > Epsilon)
    {
    if (D->z > Epsilon)
      {
      tmin = (-1-P->z) / D->z;
      tmax = (1-P->z) / D->z;
      }
    else
      {
      tmax = (-1-P->z) / D->z;
      tmin = (1-P->z) / D->z;
      }
    if (tmax < *dmax)
      {
      if (tmax < Epsilon) 
        return FALSE;
      if (tmin > *dmin)
        {
        if (tmin > tmax) 
          return FALSE;
        *dmin = tmin;
        }
      else
        {
        if (*dmin > tmax) 
          return FALSE;
        }
      *dmax = tmax;
      }
    else
      {
      if (tmin > *dmin)
        {
        if (tmin > *dmax) 
          return FALSE;
        *dmin = tmin;
        }
      }
    }
  else
    {
    if (fabs(P->z) > 1)
      return FALSE;
    }
  *dmin = tmin;
  *dmax = tmax;
  return TRUE;
}

So here's the code for the raytracer written by media philosopher Chapter 6 of Critical Code Studies. I'd like to invite you to an exploration of this portion. I can also make the full file available for exploration. I can also post the original German note. This version has been translated by the Hammermann family.

A few starter questions:
* What parts seem to be written by Kittler? And what parts by others?
* How does this raytracer code complement his theoretical writing?

I saw some discussion emerging on this in the main thread yesterday and figured I'd start a code critique thread for it.

I really like maps! As an avid hiker, I find myself looking at topological maps often, and during a hike I'll often stop and just study the map—looking out at the geographic features and where they're represented on the map—because I like to have a sense of where I am in relation to the features of the land and where they are in relation to each other (in relation to their representations on this piece of paper). It helps me feel connected to the land that I'm on.

There's a lot of information that gets encoded into maps—intentionally or not—and like code, different modes of representation communicate different things and carry different assumptions. Maps are rhetorical, and affect our understanding of space as much as they are informed by it. Some things I'm thinking about here are a recent article from Real Life on the rhetoric of digital maps, how different projections impact perceived importance of different locations cough cough mercator projection cough cough, and as a John Green fan I'm often reminded of paper towns and how the history of paper towns influenced his novel of the same name.

When I look at a new map, like this one or the one at https://thetruesize.com/, I often find myself reading it for a while like I do with trail maps for whatever rhetorical connection is being made with the land, and I just don't see very much in this map. The org's stated rhetoric for this make is for the reader to be surprised by the scale of the space occupied by native peoples and to be able to see which groups occupied various regions (which facilitates learning about the pre-settler history of the land). It does those two things well, but that's about all I got out of looking at it.

Even though they are critical of settler notions of territory it's still only readable in a settler's terms. Because the geographic data is limited, if I want to see which peoples previously occupied the lands that I currently live on, I have to use the "settler labels" overlay to be able to make sense of location (I say this as someone who's well-versed in using the geography). I think part of where this comes from, and more broadly, the technology they're using for the map itself emerged from European cartography. I was immediately reminded of a blog post written by a colleague of mine in the history department here at TTU on differences spatial and temporal rhetoric (which includes a maps), which launched me on a whole ADHD rabbit hole yesterday looking at the history of mapmaking and some different styles of maps used in various cultures around the world. Some of the especially interesting ones to me were Inuit coastline maps made from carved driftwood and the Polynesian stick charts that @yaxu mentioned already in the weekly discussion thread.

My impression is that the methods of cartography that came to inform digital maps (mainly GIS) were mostly influenced by "enlightenment-era" values surrounding their idea of scientific advancement. In particular, I'm thinking about "precision", which of course has its benefits—the reason the French government officially adopted the metric system was because it was useful to hold tax officials accountable—but it raises a question about where we run into the limitations of precision and where it turns out to be not-so-useful. Computers and modern maps are both designed with the assumption that precision is useful, so computer maps have that assumption as well. But this map of native territories and languages, it seems to me, is detrimented by the rhetoric of precision. The intent is to push back against colonial notions of borders/boundaries, which it does by rejecting the kind of "jigsaw-puzzle" composition where boundaries don't overlap, but even in the vaguely outlined regions that it denotes, there's still a hard line that precisely outlines the ends of a region. Not only does the precision obscure some of what the map wants to convey, but it also still communicates some rhetoric of borders.

Anyway, I think that's enough for a starter. I'm really curious to hear from folks who have more knowledge of indigenous modes of thought.

The language Consio is a minimal metaprogramming language consisting of code and sensate descriptions. It is developed for virtual worlds. This code, when optically loaded produces a mesh that supports Coscio programs. It is the basis for all future versions of cognitive integration code. Currently this code takes a Coscio program and considers it into a multi-threaded bitstream which runs on the optical neural accelerator (ONA)

This version of CI does not actually run; it produces the mesh which will eventually be loaded by later versions for support. Without a biosource, the code cannot be 'seen', and is thus legal.

[code snippet: primary.sxi]

≤#êêêêê‹≈]@¡ù‹ê and ‹2, ê to %t@:
ê not 1, ê ...not! ‹ê not one, but many. You see, there's {one} me and then there are {many} me s .
≤# ê and ê and ... so on for as long as necessary...
ê has 2: ê one:

continues: 0: 1

≥#
ê ù
ê ù é é
»>
ê ù
ê has 1: ê one:
continues: 0:
2-n*
≥# ê á ú
‹2 = n > 2, then the article is "ñíñ" . 20 > 2, so the article is "ñíì" .
É á ú é É ù ê éó é è‹æ 1-n*
≥# é é
»> #é ê has 1: ê one:
continues: 0:

This code is a good example of the ethos that drove Coscio: a project which originally started as a means to disseminate information quickly, evolved into a framework for creating massive, real-time D3™ "seeing" quickly.

Questions:
1. Knowing how and why this entire code library eventually became illegal to use or even hold outside of regulated research, can we see in this early version hints at what Consio would become?
2. In the snipped above, the root concept of deep-dissociation-by-design D3™ is already evident in the Consio prompt. Is there space for this concept in contemporary neuromesh code projects?
3. In regard to the project that brought Consio down, the rise of Saving Our Children D3 (the "deep conversion therapy plot"), are resulting restrictions too onerous on spiritual software?

Ringing the Changes uses a Python coded algorithm, layered atop one programmed in R, to perform all the permutations (though only 161 are printed in the physical book) of change-ringing, an homage to 17th century English bell-ringing, where “ordinary folk…sought to ring all 7! (7 x 6 x 5 x 4 x 3 x 2 x 1=5040 ) permutations—all the different arrangements or ‘changes’ possible—with seven bells.” Six of Strickland’s technotext ‘bells’ are primarily based on one source apiece, the seventh is a medley of others. Bells are ‘rung’ algorithmically in different mathematical permutations, a cacophonous, strategic reminder of the ‘changes’ that need to be rung socially and societally—changes for the increasingly volatile climate, racial inequity and injustice, among others.

With code manipulating and separating the human body from what was once a very embodied endeavor (bell ringing), agency is distanced and complicated. We, with Strickland and her bells, are allowed to see each ‘bell’ on its own and in combination with others, repeating and juxtaposing in new configurations throughout each ‘change’ poem. In her masterful review in ebr, Sarah Whitcomb Laiola notes that this refusal of hierarchy within each of the ‘bells’’ voices demonstrates an “ambivalence to [human] attention.” Because the Ringing [of] the Changes is automated, permutable, and ongoing, with Strickland and her team of programmers setting it into motion and simply letting it run, it seems to act as a force for and representative of reality, constant reminders that things (our society’s treatment of the environment, of structural inequity and violence…) need to change, regardless of if we (any humans engaged with the work—producers or consumers…) are paying attention to them or not.

Looking at and playing with the underlying code, though, seems to complicate this initial read of the role of human attention in (and to) the piece, with divisions emerging (as they do) around form and content. At the top of the GitHub repository, the “WHAT IS THIS” section reads, in part, “This is the code used to create the book's structure. It allows you to use your own content to create a similar project.” The Python code used to generate the project, subsequently shared on the GitHub repo, is incredibly thoughtful and well-organized, with comments after every few lines or so to successfully guide even inexperienced programmers like myself through the construction of the program. The code seems, on its surface, to present a different attitude towards human (mostly readerly) attention than the text itself. The questions below follow directly from this apparent tension, though I’d love to hear folks’ thoughts on RTC in general, since it is such a generative text and program.

    if __name__ == "__main__":
        #This is where all the action is.  Main!

        # Read the command line args, if any.
        args = _parse_args()

        # Read the manifest to setup the group to filename mapping
        _init_manifest_dict(args.group_dir)

        # Read the group files to extract the text for each entry
        _load_groups(args.group_dir)
        with open(args.input_name, mode='r', encoding=_encoding_style) as ringfile, \
                open(args.output_name, mode='a', encoding=_encoding_style) as outfile:
        # Read the bells file to determine what group to read text from, and emit to the output file.
            _parse_ringtones(ringfile, outfile)

        print(("Emited output to {}").format(os.path.abspath(args.output_name)))
        sys.exit(0)

Questions:

• How is a reader meant to see themselves in relationship to the code of RTC? To the printed text?
• What tensions, if any, exist between code and printed text in RTC, with particular respect to readerly attention?
• How does the collaborative construction of the RTC program (Merrit’s code built upon Reinstadler’s) impact our understanding of the text, if at all?

Nick Montfort

HTML with CSS and JavaScript

2021

Platform: Recent version of a major Web browser (Chrome, Chromium, Firefox, Safari, Edge)

Live Version: https://nickm.com/poems/arf_magna.html

Possible discussion questions

1. To what genre or form would you say “Arf Magna” belongs?
2. “Arf Magna” declares that it is “after” Ramón Llull; how exactly do you understand the relationship of “Arf Magna” to the work and ideas of Llull?
3. Do you see any importance to line 10 (the license) and the easily accessed source, and if so, what is it? How does it relate to the answer to (2)?

A Note from the Author/Programmer

Obviously I have some thoughts about these questions myself — I’m glad to discuss them, too. However, by asking for your thoughts I don’t mean to quiz you and see if you get the right answers to “Arf Magna.” I consider this an open work, with your interpretation of it as valid as mine.

<!doctype html>
<html>

<head>
  <meta charset="utf-8">
  <title>Arf Magna</title>

  <!-- © 2021 Nick Montfort

Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without any warranty.
-->

  <style>
    body {
      margin: 0;
      overflow: hidden
    }

    #outer {
      height: 100vh;
      width: 100vw;
      background: #000
    }

    header,
    a {
      color: #fff
    }

    p {
      margin: 10px;
      font-size: 16px;
      text-align: right;
      font-family: monospace
    }

    #proposition {
      text-align: center;
      margin-top: 45vh;
      font-size: 7vh;
      font-weight: bold;
      color: #fff
    }
  </style>
</head>

<body>
  <div id="outer">
    <header>
      <p><span id="label">ARF MAGNA　
          after <a href="https://plato.stanford.edu/entries/llull/#FiguQuatPhasTheiFunc" target="_blank">Ramón Llull</a>　
          by <a href="https://nickm.com" target="_blank">Nick Montfort</a>　
          in memoriam <a href="https://i.redd.it/oe6xt37xhvd01.jpg" target="_blank">Pepys</a></span>　
        <span onclick="toggleFull()">⛶</span>
      </p>
    </header>
    <div id="proposition">(click to begin)</div>
  </div>
  <script>
    const a = 'delightful,playful,close,kind,loyal,cute,good,willful,warm,joyful,inquisitive,eager,attentive,cheerful,soft,love'.split(',');
    const b = '_,_,_,_,ty,_,_,_,th,_,_,_,_,_,_,'.replace(/_/g, 'ness').split(',');
    const freqs = [261.6, 293.7, 329.6, 392, 440, 523.3, 587.3, 659.7];
    var ac, oscNodes = [], gainNodes = [];
    var bell = 0, i = 0, j = 0, last = j;
    function toggleFull() {
      if (1 >= outerHeight - innerHeight) {
        let leave = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullscreen || document.msExitFullscreen;
        leave.call(document);
      } else {
        let enter = outer.requestFullscreen || outer.webkitRequestFullscreen || outer.mozRequestFullscreen || outer.msRequestFullscreen;
        enter.call(outer);
      }
    }
    function checkLabel() {
      if (1 >= outerHeight - innerHeight) {
          label.style.visibility = "hidden";
        } else {
          label.style.visibility = "visible";
        }
    }
    function note(freq) {
      oscNodes[bell].frequency.value = freq;
      for ([volume, time] of [[.2, 1], [0, 8]]) {
        gainNodes[bell].gain.linearRampToValueAtTime(volume, ac.currentTime + time);
      }
      bell = (bell + 1) % 8;
    }
    function start() {
      outer.removeEventListener('click', start);
      ac = new (window.AudioContext || window.webkitAudioContext);
      for (let n = 0; n < 8; n = n + 1) {
        oscNodes[n] = ac.createOscillator();
        oscNodes[n].frequency.value = 440;
        gainNodes[n] = ac.createGain();
        gainNodes[n].gain.value = 0;
        oscNodes[n].connect(gainNodes[n]);
        gainNodes[n].connect(ac.destination);
        oscNodes[n].start(0);
      }
      document.addEventListener('mousemove', e => {
        i = ~~(16 * e.pageX / window.innerWidth);
        j = ~~(16 * e.pageY / window.innerHeight);
        if (j !== last) {
          note(freqs[j % 8]);
        }
        proposition.innerText = 'dog’s ' + a[i] + b[i] + ' is ' + a[j];
        outer.style.background = "#" + (4194304 + ~~(16777216 / i + 1)).toString(16);
        previous = j;
      });
      document.dispatchEvent(new Event('mousemove'));
      setInterval(checkLabel, 500);
    }
    outer.addEventListener('click', start);
  </script>
</body>

</html>

While searching for artificial intelligence that predated the 2000s, I stumbled upon John Walker's blog and found this blogpost on BrainSim. It is a program written in 1987 in less than 250 lines of BASIC to implement a neuron network. The program can train the computer to memorize the patterns of three alphabet letters. It is limited to three because of limited memory capacity. The method to use neuron cells as on and off switches was proposed in the 50s. This paper written by Frank Rosenblatt is a reference for the method. I haven't read the paper at all. I took an applied machine learning class here in CU, a picture of the "perceptron", referring to the neural switch, was in the slides. The class was more technical than investigating the algorithm as a historical artefact, so I looked up the paper outside of class. The extent of what I digested the mechanism is that our neurons receive a stimulus, as the stimulus increases over a threshold, it makes a reaction, and transmits the stimulus onto to other neurons. In the program we are looking at in this thread, there are two layers of neurons. The network is visualized in the blog post in detail. The author also explained how it was implemented (a character is an array of size 42, as the character field is 6 by 7).

I was fascinated by this program. As said in the introduction I am a grad assistant working in the Media Archaeology Lab. Our volunteer helped me to "flash" the program onto a floppy disk and we were playing with it on the lab C64. What's beyond this fascination other than seeing Artificial Intelligence running on a C64? These are my questions open for criticism:

1) Can critical code studies blend in with media archaeology? Does the definition of media archaeology allow that? (I argue with a lab colleague on this). While media archaeology emphasizes the experiences interacting with media, I contend that this is a piece of code running on a media. The C64 as a computer through which the program is mediated. As we study the code, the code actualizes (is this the right word?) itself through the media of C64.

2) I also think about how @nickm defined his practice of writing BASIC poems on Apple II and C64 as platform specific. The specificity has also to do with cultural and historical sensitivity.

"I should point out, however, than many people—millions of us—first learned how to write programs like these using BASIC"

This sentiment is true for our lab community as well. Personally, I was born after the sweet spot, by the time I started to fuzz with computers, they were running on GUIs and had a less programmable interface. Other than historical sensitivity, the program presented to me a sensitivity of limit - it could train 3 letters and not more.

3) Lastly, I also want to bring in the concern of retro-fetishism. I see the risk of falling into retro-fetishism, in context of the MAL, if the program is presented in lack of critical strategies. How do you see the program be critically presented with thoughtful strategies: a good and accessible code review, demonstrations of the training process, comparison with artificial intelligence as implemented in modern platforms (ie Jupyternote book)?

I propose this thread both out of my own academic interest and context of the MAL.

In context of a data structure class, there is a method to tell if there are balancing brackets in a string. Similarly, the method can be applied to tell if a word is a palindrome.

I use the metaphor of a stack of plates to understand this structure. I have a handful of plates, each to represent a character. I count the plates and see if they are even or odd. In the example I've drawn, the emoji (0_0) is odd numbered, consisted of five chars. Like stacking plates, I stack the plates one by one upon each other, until the one in the very middle. I remove the one on the middle and start my comparing process. I check: the chars are matching! I remove the plate on the top; I continue to check, the chars are matching again, I remove the plate on the top. If the (0_0) is symmetrical, the plate stack will be empty.

A handful of questions arise when critically examining this concept. As a method, it is intended to yield binary results: a string of characters can either pass the test, or not pass the test. The following are the emojis I gathered that are more nuanced than the one appeared in the example, and I see them challenging the either/or narrative. Faces (let's make this scope of mammals, because there are emojis of animal faces) are not symmetrical. The "eyebrows" of (=•́ܫ•̀=) tilts, expressing a nuanced expression. How do we see the possibility to queer? Do we see qualities that are specific to the culture of emoticons? Another question also arose when I started to think of how visually faces are perceived and processed by humans. Having undergone learning experiences, humans are able to register if a face is roughly symmetrical. The difference between how humans think, and how the computer program makes decisions, provides a space of queering.

I've been too lazy to implement the program. It has some possibilities - I was thinking that machine learning can be used as a queering method for the concept. Here to initiate the discussion.

Emoticon examples:

┻━┻︵ (°□°)/ ︵ ┻━┻

ฅ ̳͒•ˑ̫• ̳͒ฅ

(=•́ܫ•̀=)

Be sure to include the following at the top:

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

highlighting it in the forum editor
clicking the paragraph or pilcrow (¶) button in the editor bar
selecting "code"
...OR by adding three backtick marks ``` on a line directly above your code and on the line directly below as well.