[PRACTICE] Queer Code Poetry Jam

Comments

• edmondchang

  February 10 edited February 10

  I have been thinking about recipes as algorithms, as a kind of code poetry--I had ChatGPT write a poem about queer grief in the form of a baking recipe (a riff on the code poem above):

  Recipe: Bittersweet Farewell Cake

  Ingredients:

  2 cups of lost love, gently sifted
  1 cup of whispered vows, finely chopped
  1/2 cup of tender light, melted
  1 teaspoon of cold and hollow space
  A pinch of twilight tears
  3 cups of aimless wandering
  2 tablespoons of empty halls
  A handful of aching hearts
  Echoes of love, to taste
  1 bright beacon, optional
  1 flickering flame
  A dash of endless sorrow
  A sprinkle of resilience

  Instructions:

  Preheat your oven to the temperature of silent longing.
  In a large mixing bowl, combine lost love, whispered vows, and tender light. Stir gently until well incorporated.
  Add cold and hollow space to the mixture, then fold in twilight tears until the batter thickens.
  In a separate bowl, whisk together aimless wandering and empty halls until smooth.
  Carefully pour the second mixture into the first, stirring gently to blend all ingredients together.
  Sprinkle in aching hearts and echoes of love, ensuring they are evenly distributed throughout the batter.
  If using, fold in the bright beacon for an extra touch of guidance.
  Transfer the batter to a prepared baking pan, then sprinkle the top with the flickering flame.
  Bake in the preheated oven for as long as it takes for the cake to rise and set, allowing the flavors to meld and deepen.
  Once baked, remove the cake from the oven and let it cool slightly on a wire rack.
  Garnish with a dash of endless sorrow and a sprinkle of resilience before serving.
  Slice and savor each bittersweet bite, knowing that even in loss, there is strength and growth.

  It's a little emo and maudlin, but strangely compelling.
• markcmarino

  February 11

  @Edmond, a poignant recipe. I wonder if @DanielTemkin could make a version in Chef?

  Staying with our theme of loss and your recipe, which queers code by transgressing the constructed or normalized boundaries around media forms and spaces of making, in the spirit of our Knit&Perl discord group and the 2022 CCSWG week on the Fibre Arts, let me offer this crossstitch pattern I generated of Alan Turing using stitchfiddle as another codework.

  

  But let us not forget queer joy!
• markcmarino

  February 11

  In the code critique thread about The Gay Science, @DanielTemkin mused that we might have a kind of codework emerging from prompts for AI code generation. Continuing these themes of grief and cooking, I offer this prompt that I have entered into ChatGPT. I have written it from the vantage point of a character who has experienced loss along the lines that Edmond's pieces express, and hope that fictionalizing does not coopt the suffering but instead extends an expression of sympathy:

  I have lost someone dear to me, my life partner, my soulmate. We used to cook together. Well, I cooked "can to pan," and he cooked from scratch, meaning whatever he could scratch up, having been raised by a single mom who worked three jobs, and could fry a near minimum wage paycheck into a banquet. Can you write a small Inform 7 room made of the last shopping list he made for me and my empty refrigerator. Generate a simple mechanism out of examine (x) list and (x) fridge that creates a loop of loss and morning, escaped only when the person realizes they have enough to make his favorite overnight Goats, aka the greatest overnight oats his mother used to leave for him to eat before he went to school without seeing her.
• Stefano

  February 11 edited February 11

  <?php
  /*
  * me_myself_and_other_mes.php
  * 
  * Copyright 2024 Stefano Penge <stefano@stefanopenge.it>
  * 
  * This poem is free software; you can modify
  * it under the terms of your own desire 
  * and/or you can redistribute it in terms of your wish to share emotions or
  * (at your option) in terms of any other reason or feeling.
  * 
  * This poem is distributed in the hope that it will be delightful to read,
  * but WITHOUT ANY WARRANTY of givint happiness to the reader; 
  * without even the implied warranty of
  * FITNESS FOR A PARTICULAR STATE OF MIND.  See the
  * universal history of literature for more details.
  */
  
  /*
  * I decided to show you all my desires.
  * First of all, I have to discover: who am I?
  * How may mes are there?
  */
  forEach (get_declared_classes() as $OneMe){
  if (
      ($OneMe == 'MySelf') 
  OR 
      (is_subclass_of($OneMe,'MySelf'))
  ) {
      $I = new $OneMe;
      $I->showDesires($I->desires);
      // $I->showDesires($I->secretDesires); this line shouldn't be executed in public
  }   
  }
  
  /* Identities declarations:
  *               MySelf
  *                  |
  *      ___________________________
  *      |           |              |
  *     Me         OtherMe      AnotherMe
  * 
  */     
  
  Class MySelf {
      public $desires;
      private $secretDesires;
      public function __construct(){
          $this->desires = "to be happy forever!";
      }
      public function showDesires($desires){
          echo "I am ".get_class($this);
          echo ". My desires are ".$desires."\n";
      }
  }
  
  Class Me extends MySelf {
      public $desires;    
      private $secretDesires;
      public function __construct(){
          $this->desires = "...";// please add yours
      }
  }
      Class OtherMe extends MySelf {
          public $desires;
          private $secretDesires;
          public function __construct(){
              $this->desires = "...";// please  add yours
          }
      }
          Class AnotherMe extends MySelf {
              public $desires;
              private $secretDesires; 
              public function __construct(){
                  $this->desires = "...";// please  add yours
                  $this->secretDesires = "..."; // please  add your   _private_ desires   
              }
          }
  

  ======
  This piece of code written in PHP 8 is about the construction of multiple identities and the structure of desires.
  First of all, please read carefully the license: it is part of the code.
  Then read the code; it should be clear even for those without an experience in object oriented programming. Basically, in the second part there is a hierarchy of selves; in the first, there is a process of auto-discovering identities and showing each identity's desires.
  Then, if you like, add some desires (a class property) or some identites (a class, subclass of MySelf).
  Be careful about revealing secret desires... It can hurt.
• Temkin

  February 11

  @Edmond, a poignant recipe. I wonder if @DanielTemkin could make a version in Chef?

  For those unfamiliar, Chef is an esoteric programming language where a source text reads as a cooking recipe, very similar in format to what Edmond posted -- it makes literal recipes-as-algorithms.
• edmondchang

  February 11

  @Temkin: That's very cool!
• edmondchang

  February 11

  @Stefano: Really neat! I am thinking about if I understand all of the moves being made. Wow, we are all getting really existential in our poems!
• Stefano

  February 12

  @edmondchang thanks! Perhaps one can read it as a fragment of life: someone ($I) deciding to better understand which are her/his ($I->) deep desires.
  The first part (24-34) is an (auto)analysys with some fundamental questions: who am $I? which are my desires ($I->desires) (and, optionally, my secret ones)? This is done asking to the PHP interpreter to loop among the class in memory at run time (get_declared_classes) and filtering only those related to class MySelf (is_subclass_of). Note also that the way desires are shown is delegated to classes: every class - or, identity - may have a specific way to communicate its desires. We will discover later that sub-identities have specific desires but no specific ways to show them.
  The second part (45-76) could be seen as what is discovered thanks to the analysis: there are multiple identities with different desires set at their born. This part of the story happened before the act of the analysis but is discovered only afterwards. This is a little reminder of the fact that programming language poems shouldn't be read necessarily from the first line to the last one as a natural language poems.
  This part relies on the idea of object oriented paradigm, that is well suited to represent relationships among concepts more than sequences of operations. MySelf is a super class, with its properties ($desires and $secretDesires) and its method (showDesires()). The other classes are subclasses of that one (they extends it).
  Every class has a "magic" function __construct(). This function is called whenever a new object of this class is born (as in line 30). Clearly every class does whatever she wants: in our case, they just set their desires and their secret desires, but as I say before they could redefine superclass methods, like showdesires(): they could whisper their desires sing them loud, write a poem about them, ... with the exception of sectredDesires, that are declared private (47), so cannot be accessed by public method.
  I see this process of specialising a competence like a zooming: the more the analysis proceeds, the more $I understand that not only can have pluri-identities and pluri-desires (event in contrast one with another) but also different way to deal with them.
  This, I think, was the main idea behind this small poem: a meta declaration of the fact that $I - the poet? the interpreter? the fictional character? - has to be open to surprises when trying to analyze her/him self.
• Temkin

  February 12

  @Stefano: I like how the hierarchy of subclasses opens the possibility to further refine our public desires even more specifically: a work self vs a work self in front of a specific coworker perhaps, and how we play at being ourselves differently in these micro-contexts.
• HarlinHayleySteele

  February 12 edited February 12

  @edmondchang Thank you so much for this prompt!

  Here's a little poem I'm going to call "You have permission to be yourself". It is written in so-called "binary" from the perspective of the machine.

  [How to read this poem:

  Imagine an electrical current flowing through the circles, taking their shape. The larger circle is what humans call "zero." The smaller circle is what humans call "one." This is not a fantasy, but the physics of the machines we interact with everyday.]

  -

  You have permission to be yourself

  0o0o0o000oo0o0000oo00o0o0ooo00o00oo00o0o00o00ooo0ooo00oo00o000000oo0000o0oo0ooo000o000000oo00o0o0oooo0000ooo00000oo00o0o0ooo00o00oo0o00o0oo0oo0o0oo00o0o0oo0ooo00ooo0o000oo0000o0oo0oo0000o000000oo0oo0o0ooo0o0o0ooo00oo0oo0o00o0oo000oo00o000000ooo00oo0oo0oooo0ooo0o0o0oo0ooo00oo00o0000o000000oo0000o0ooo00o00ooo0o000oo0o00o0ooo00oo0ooo0o0000o000000oo000oo0oo0000o0oo0oo000oo0oo000oo00o0o0oo00o0000o000000o000o000oo0o00o0ooo00o00oo0000o0ooo00o000o000000o00o0oo0oo0000o0oo0oo000oo0000o0ooo00oo0oo0o00000o0oo0000o000000ooo0ooo0oo0o0000oo0oooo00o000000ooo0ooo0oo0oooo0ooo00o00oo0o0oo0oo00o0o0oo00o0000o000000oo0oooo0oo0ooo000o000000oo0000o00o000000ooo00oo0oo00o0o0ooo000o0ooo0o0o0oo00o0o0oo0ooo00oo000oo0oo00o0o00o000000oo0oooo0oo00oo000o000000oo0o00o0oo0ooo00ooo0o000oo00o0o0ooo00o00ooo0oo00oo00o0o0oo0ooo00ooo0o000oo0o00o0oo0oooo0oo0ooo00ooo00oo00o000000ooo0o000oo0o0000oo0000o0ooo0o0000o000000ooo0ooo0oo00o0o0ooo00o00oo00o0o00o000000oo0000o0oo0oo000ooo00oo0oo0oooo00o000000oo0o00o0oo0ooo00ooo00oo0ooo00000oo0o00o0ooo00o00oo00o0o0oo00o0000o000000oo000o00oooo00o00o000000ooo00o00oo0000o0oo00o000oo0o00o0oo0oooo00o000000ooo00000ooo00o00oo0oooo0oo00ooo0ooo00o00oo0000o0oo0oo0o0ooo00oo00o000000ooo0o000oo0o0000oo0000o0ooo0o0000o000000ooo0o0o0ooo00oo0oo00o0o0oo00o0000o000000ooo0o000oo0oooo00o000000oo000o00oo00o0o00o000000oo00oo00oo0oooo0ooo0o0o0oo0ooo00oo00o0000o000000oo0o00o0oo0ooo000o000000o0o00000oo0000o0oo0oo000oo00o0o0ooo00oo0ooo0o000oo0o00o0oo0ooo00oo00o0o00o0oo0000o000000ooo0ooo0oo0o0000oo00o0o0ooo00o00oo00o0o00o000000oo0000o0oo000oo0ooo0o000ooo0o0o0oo0000o0oo0oo000oo0oo000oooo00o00o000000ooo0o000oo0o0000oo00o0o00o000000oo00oo00oo0000o0oo0oo0o0oo0o00o0oo0oo000oo0o00o0oo00o0o0ooo00oo00o000000oo0oooo0oo00oo000o000000ooo00000ooo00o00oo0o00o0ooo00oo0oo0oooo0oo0ooo00oo00o0o0ooo00o00ooo00oo00o000000ooo0ooo0oo0oooo0ooo0o0o0oo0oo000oo00o0000o000000ooo00oo0ooo00000oo00o0o0oo0000o0oo0o0oo00o000000ooo0o000oo0oooo00o000000ooo0o000oo0o0000oo00o0o00o000000ooo00000ooo00o00oo0o00o0ooo00oo0oo0oooo0oo0ooo00oo00o0o0ooo00o00ooo00oo00o000000ooo0o000oo0o0000ooo00o00oo0oooo0ooo0o0o0oo00ooo0oo0o00000o000000ooo0o000oo0o0000oo00o0o00o000000ooo00o00oo0000o0oo00o000oo0o00o0oo0oooo00o0ooo0

  -

  Footnote:

  There is nothing essential or necessarily more efficient about building machines this way. Doing it this way was a design choice. We use labels like "one" and "zero," to hide the reality that something rather freaky is going on under the machine language, at the level of the machine. One is always smaller than zero, at least as far as the voltage level is concerned, and neither of them is an "off." There is no "off." Zero is a wholeness, and to become a one, it scrunches up a little.
• Temkin

  February 13

  @HarlinHayleySteele:

  I love this invoking of the analog inside the digital. I'm imagining the mini-spikes where the voltage goes off a little bit, but not enough to turn 0 into o. A change that is invisible to the discretizing force of the digital (whether binary or ternary or something else).
• HarlinHayleySteele

  February 13 edited February 13

  @Temkin Thanks so much! I was having a hard time trying to decide which characters to use to represent the stuff going on below the machine language.

  One reason I chose circles here was to evoke the sense of the space the current occupies, with the goal to help folks imagine what it’s like to be the electrical current that is, to borrow a term from linguistics, the ‘articulator’ of the machine.
  My understanding is it’s more like mini-drops (rather than spikes), since zero is the whole voltage, and one is obtained by bapping it down from there.

  I wonder which characters would you use to represent what’s going on below the binary, at the level of the machine? Perhaps you have a different way in mind? I’d be curious to see ✨

  But also, I think if I’d been doing a ternary machine, I would have done things quite a bit differently…
  Yesterday I was thinking about how the 1/0/-1 of balanced ternary maps on to some models of the cosmos (heaven, the Earth, the descent into the underworld). Adding just that extra digit really seems to open things up, as far as interesting metaphors go.
• Temkin

  February 13

  One reason I chose circles here was to evoke the sense of the space the current occupies

  It definitely reads that way; the 0 and o feel like open and closed, like different states of the same shape.

  I wonder which characters would you use to represent what’s going on below the binary, at the level of the machine?

  Hmm that's hard because using an enumerable set of symbols already makes it digital, whether it's 0 and 1 or a larger list of symbols. If the idea is to "remain analog," the symbol(s) would need to be adjustable; perhaps a series of circles where they are drawn to the proportion of the voltage without locking it down to a specific set of choices, so that any two might have a circle sized halfway between them...

  the 1/0/-1 of balanced ternary maps on to some models of the cosmos (heaven, the Earth, the descent into the underworld)

  That is beautiful. What will it mean when every number has some proportion of heaven and earth to it? I do like the aesthetic of considering numbers in relation to three; splitting in threes is more natural to me than halving.

  The reference to ternary and the underworld reminds me of the esolang Malbolge (named for a level of hell). It's a 0/1/2 ternary machine with no addition or multiplication; math can only be performed by a single tritwise operator called "crazy."

  Also, I made an esolang called Light Pattern, where code is written in photographs. Changes in exposure and color from one photo to the next are translated into a three-trit ternary number that maps to a command.
• Stefano

  February 14 edited February 14

  @Temkin I loved Piet, but Light Pattern will be definitely my favourite esolang from now on !!!
• Temkin

  February 14

  Thanks @Stefano! Piet was a big inspiration. Also, its creator David Morgan-Mar is the same person who created the Chef language mentioned upthread. I interviewed him years ago
• HarlinHayleySteele

  February 17 edited February 17

  @edmondchang It's kind of wild how when you asked Catfart (which I hear is the french name for Chat GBT) to create a love poem in code, it defaulted towards such a hetero-monogamous situation. I'd be curious to learn if a request for queerness was part of the prompt, which would make the heterosexual technonormativity even more glaring (I hope I'm using that term right!)(Like, is the phrase "heterosexual technonormativity" redundant, I wonder?)

  It's wild how cutting that recipe poem is! Thank you for sharing it. I was messy crying yesterday after reading it, thinking about all the people who aren't here anymore who might still be here if there had been spaces like this sooner. (I'm grateful this space is here. Thank you for holding it!) But yeah, I guess the AI got to me... But is it really AI that wrote that poem? Whose ghosts, I wonder, came through in the text the AI was trained on?

  Anyway... a little rambling...

  @edmondchang's two works at the top of this thread really have me thinking about how the Hays Code and its aftermath--plus the Lavendar Scare purges in Hollywood--has skewed the source material that the algorithms and AIs/LLMs draw from, which has in turn likely biased them towards queer grief rather than queer joy. (At least for the ones you don't train yourself! It's so funny how queer folks never get the benefit of the default! It seems like everything for us needs to be bespoke or bust...)

  This way of thinking hecka draws from Ruja Benjamin's book on "the New Jim Code," and her explorations of the way, without care and interventions, code and tech can lock in and escalate pre-existing forms of racism. Your work (Chang 2021) seems to imply that we should be thinking about gender in the same kind of way?

  But like, is it enough to merely correct the AI? Or do we need to now even out the source material now by spending the next 90 years depicting queer joy in film and narrative media? 😁
  Thanks, @markcmarino for bringing up queer joy with your knitting/Perling (!)

  And @Stefano's code poem with its secret desires really brings to mind for me ideas of "the closet," or, as the young people have been telling me, rather than "coming out" the new discourse is all about "bringing people in."

  But also I wonder is there is also a space for queer rage in queer coding?
  After all, the first Pride as was a riot...
• markcmarino

  February 17

  Love those ideas for trying alternate prompts @HarlinHayleySteele -- and glad to learn the French name of ChatGPT (is it le Chatfart?).

  In our discussion of Queer Theory yesterday, I pointed out how ChatGPT seemed capable of drawing on the more abstract notions of Queer Theory to disrupt or destabilize norms. It's interesting that when it created the recipe it did not go in that direction. I think your nonbinary code poem does that. Perhaps Mez's mezangelle does as well, by blurring the boundary between code and natural language. But I guess there is a difference obviously between queer identity and queer critical practice.

  This is a long rambling way of asking what queering code poems might look like? Perhaps Zach Blas' Transcoder library gives one expression -- with unprocessable code that embodies queer theory. But I'd be eager to see (a rainbow of) other expressions of queering in codeworks.
• HarlinHayleySteele

  February 18 edited March 6

  @markcmarino You're talking about the synchronous discussion we had on Zoom, right?

  Thanks for bringing up and Zach Blas' Transcoder library and Mez's mezangelle. I really enjoy Blas' re-imagining of "the Gay Bomb", and this idea of using existing channels of transmission to spread queer love (queer love bombs? Lol).

  Lately, I've been feeling especially drawn to theorists of Indigenous and pre-colonial ways of knowing gender, like the work of Joshua Whitehead (Oji-Cree), Mark Rifkin, and Gopi Shankar, alongside thinkers working within the imperial (base-2) gender paradigm like Silvia Federici. I mean, why are empires so obsessed with dividing the entire populace into two "gender" groups, with one given power the other? I ranted about this at GenCon. I mean, the knowledge about 3rd, 4th, and 27th genders is constantly being stolen from us, these things have to be constantly reiterated so they aren't swept away in the imperial dyadic-normalizing tide. I mean, maybe I'm gazing too hard into the wound/repressive parts, but I think it was Miss. Frizzle who once said, "If at first you don't succeed, find out why..."

  All this is to say, my approach to queering is weirdly pragmatic. I mean, Karen Barad's queering of physics isn't just about poetics. There's a practicality to the queering of physics, insofar as it allows interventions into myths about physical reality that are not just homophobic, but inaccurate. That are inaccurate because they are homophobic. Paranoia about being perceived as queer within a society that punishes gender nonconformity leads people to misspeak about what they are seeing, to crop and airbrush everything so to hide anything that might be perceived as queer, and in doing so, reality itself is obfuscated, which is a real bummer for folks who genuinely want to figure out how things work!

  I've been trying for years to understand why everyone seems to explain computer circuitry wrong, and a weird type of homophobia seems to be at play. Homophobia blended with the fact that no one has time to gain intimate, working, craftsperson knowledge of computers. You know slow reading, right? I dream of doing a Digital Humanities slow build of computers from the raw physics on up. Wouldn't it be fun to do multiple types of machines, with different logics to their circuits, side-by-side, while talking about it the whole time, writing poems about what we see? Playing with metaphors.

  The "on/off" thing is a lie. Fully modern, electric digital computers don't work that way. They never have.

  But folks shouldn't have to take my word for it. I think everyone should have a chance to build a computer from scratch, preferably before they reach middle school. If people knew. how this stuff worked, they'd have a harder time assigning these weird, dyadic-gender-based myths to things.
• HarlinHayleySteele

  February 19 edited March 6

  Thanks for your interest, @Temkin! I felt motivated by your comments to start digging around in the archives and found these two abstracts laying out the specs of Maddida (the first computer with fully modern digital circuits) written for the AMC gathering in 1950 (see pages 17-18).

  It seems like the design team didn't even actually use "1" or "0" at all to talk about the machine’s logic!

  It looks like they were using using "x" and "+."

  (I had always just assumed the origional designers is where the myth started, but I guess not (!)

  Here's a quote the abstract I found particularly interesting:

  A logical algebra using the “+” and “x” operators to define those operations directly accomplished by diodes, namely, the “inclusive or” and the “and,” is utilized to write complete equations about each grid of every flip-flop in the machine. The memory record functions are also written in this algebra.

  ^From the AMC abstract for Maddida, the Eckdahl one (see page 18) (You have to overlook the fact that it's a differential analyzer rather than a general purpose computer. It was the first machine to use voltage levels to specify all the digits at the level of the machine language, which in this case was base-two, representing them both as having something there, rather than there being anything that's "off" from an electrical sense.- There is no "off." - This machine interpreted two different shapes as being "x" and "+," and these symbols were assigned to those shapes. They are at the basis of its logic/code. It is my understanding that all mass-produced digital circuitry since this time has followed this small configuration.)

  I had always assumed that the original creators of the first fully modern digital computer were complicit in the lie that zero is an "off." But now, as I'm looking over the way they wrote about the machine when they were sharing it with their peers at AMC in the 1950, I'm seeing they don't 1" or "0" anywhere.

  I'm imagining there must have been some odd social forces at play that led this machine to become closeted; to start being labeled as having an "on" and "off" when in reality it just has two different shapes/voltage levels that are both a "there-ness." I imagine a number of social and political forces were at play in why this machine--and all mass-produced digital machines since--were mis-labelled using "1/0" and "on/off" descriptors that don't match what is going on at the level of the machine.

  Also, here's something interesting. In the specs above, the way they are thinking of the two shapes (which are both different variations of "on") is like this:

  "x" = "inclusive or"
  "+" = "and"

  Other parts of the abstract and article linked above get into how maddida was the first fully modern digital machine, and the thing it did different than other supposedly base-2 machines that came before it was it represented both digits as voltage levels, and all other digital machine since have done this.

  Where the code touches the machine

  I feel weird "outing" ENIAC like this,
  but ENIAC isn't the first truly modern digital machine.

  I mean, ENIAC could put on the show.
  And that should be enough, right?
  But the transition wasn't complete.
  (Am I going to get into trouble for saying this?)

  ENIAC did all the things a digital machine should
  from the outside at least, but internally,
  not so much. It gets mis-labelled as
  being fully transitioned to the digital,
  when it wasn't.

  If you want to find a fully modern digital circuit,
  you have to look towards Maddida.
  Maddida is where things fully transitioned.
  (Is it deadnaming to claim it was ENIAC?)

  And there's no "off" in Maddida.
  Just two different variations of "on."
  Two different voltage levels.
  They are always on—
  They just make slightly different shapes.

  In all of our computers,
  zero is not an "off"
  but rather a different shape of "on"
  Both digits have a presence. There is no "off."

  So, the original designers of the first computer with fully modern digital circuitry didn't use "1" or "0" at all to talk about their machine (at least not as they were launching it). Instead, according to their own words, they used these symbols:

  "x" = "inclusive or"
  "+" = "and"

  And at first when I saw this in their abstract from the 1950 AMC gathering (see pages 17-18), I was super confused.

  Like, what's up with the way they are using "inclusive or" and "and"? I mean, these terms show up as technical terms in Boolean, sure. But the way the designers are using the terms in the abstracts seems rather different. After thinking about this for way too many hours, I think they are using the terms as nicknames for these symbols. I mean, the specks don't match up with the part where you'd put the Boolean (this is like 3 levels lower than that), and also, in other parts of this IEEE article, the lead engineer didn't really grasp the Boolean anyway, a fact which seems to be confirmed in this Smithsonian interview with the lead engineer from 1973, in which he says, "I was naïve; I thought I’d invented the binary system. Really I did." (Mapstone 1977). Like, everything seems to indicate that the team, by the time they were showing the machine at the AMC in 1950, had a couple idea from Boolean, but the thing wasn't actually specified in Boolean (See: Page 10 of this IEEE article). What math even is this??

  But like, at the level of the physics - at the level of the machine's "articulators" (to borrow a term from linguistics) - it looks like we have these two separate voltage levels (neither is an "off") and yeah, based on what I'm seeing in their 1950 AMC abstracts for MADDIDA, that they were using "x" and "+" rather than a "1" and "0."

  (The original design team for the first fully modern digital circuit didn't use "0" and "1"!!!)
  (I wonder if they were just bullied into closeting their machine because others in the field who didn't have the expertise to check assumed there was an "off" like ENIAC?)

  So...getting back to the poem that is the point of this -

  If I write my poem out in the original way the designers of the first fully modern digital machine were using to label what's going on at the very bottom of all the code, at that first layer that wafts up from where the code touches the machine, this is what I get:

  You have permission to be yourself
  x+x+x+xxx++x+xxxx++xx+x+x+++xx+xx++xx+x+xx+xx+++x+++xx++xx+xxxxxx++xxxx+x++x+++xxx+xxxxxx++xx+x+x++++xxxx+++xxxxx++xx+x+x+++xx+xx++x+xx+x++x++x+x++xx+x+x++x+++xx+++x+xxx++xxxx+x++x++xxxx+xxxxxx++x++x+x+++x+x+x+++xx++x++x+xx+x++xxx++xx+xxxxxx+++xx++x++x++++x+++x+x+x++x+++xx++xx+xxxx+xxxxxx++xxxx+x+++xx+xx+++x+xxx++x+xx+x+++xx++x+++x+xxxx+xxxxxx++xxx++x++xxxx+x++x++xxx++x++xxx++xx+x+x++xx+xxxx+xxxxxx+xxx+xxx++x+xx+x+++xx+xx++xxxx+x+++xx+xxx+xxxxxx+xx+x++x++xxxx+x++x++xxx++xxxx+x+++xx++x++x+xxxxx+x++xxxx+xxxxxx+++x+++x++x+xxxx++x++++xx+xxxxxx+++x+++x++x++++x+++xx+xx++x+x++x++xx+x+x++xx+xxxx+xxxxxx++x++++x++x+++xxx+xxxxxx++xxxx+xx+xxxxxx+++xx++x++xx+x+x+++xxx+x+++x+x+x++xx+x+x++x+++xx++xxx++x++xx+x+xx+xxxxxx++x++++x++xx++xxx+xxxxxx++x+xx+x++x+++xx+++x+xxx++xx+x+x+++xx+xx+++x++xx++xx+x+x++x+++xx+++x+xxx++x+xx+x++x++++x++x+++xx+++xx++xx+xxxxxx+++x+xxx++x+xxxx++xxxx+x+++x+xxxx+xxxxxx+++x+++x++xx+x+x+++xx+xx++xx+x+xx+xxxxxx++xxxx+x++x++xxx+++xx++x++x++++xx+xxxxxx++x+xx+x++x+++xx+++xx++x+++xxxxx++x+xx+x+++xx+xx++xx+x+x++xx+xxxx+xxxxxx++xxx+xx++++xx+xx+xxxxxx+++xx+xx++xxxx+x++xx+xxx++x+xx+x++x++++xx+xxxxxx+++xxxxx+++xx+xx++x++++x++xx+++x+++xx+xx++xxxx+x++x++x+x+++xx++xx+xxxxxx+++x+xxx++x+xxxx++xxxx+x+++x+xxxx+xxxxxx+++x+x+x+++xx++x++xx+x+x++xx+xxxx+xxxxxx+++x+xxx++x++++xx+xxxxxx++xxx+xx++xx+x+xx+xxxxxx++xx++xx++x++++x+++x+x+x++x+++xx++xx+xxxx+xxxxxx++x+xx+x++x+++xxx+xxxxxx+x+xxxxx++xxxx+x++x++xxx++xx+x+x+++xx++x+++x+xxx++x+xx+x++x+++xx++xx+x+xx+x++xxxx+xxxxxx+++x+++x++x+xxxx++xx+x+x+++xx+xx++xx+x+xx+xxxxxx++xxxx+x++xxx++x+++x+xxx+++x+x+x++xxxx+x++x++xxx++x++xxx++++xx+xx+xxxxxx+++x+xxx++x+xxxx++xx+x+xx+xxxxxx++xx++xx++xxxx+x++x++x+x++x+xx+x++x++xxx++x+xx+x++xx+x+x+++xx++xx+xxxxxx++x++++x++xx++xxx+xxxxxx+++xxxxx+++xx+xx++x+xx+x+++xx++x++x++++x++x+++xx++xx+x+x+++xx+xx+++xx++xx+xxxxxx+++x+++x++x++++x+++x+x+x++x++xxx++xx+xxxx+xxxxxx+++xx++x+++xxxxx++xx+x+x++xxxx+x++x+x++xx+xxxxxx+++x+xxx++x++++xx+xxxxxx+++x+xxx++x+xxxx++xx+x+xx+xxxxxx+++xxxxx+++xx+xx++x+xx+x+++xx++x++x++++x++x+++xx++xx+x+x+++xx+xx+++xx++xx+xxxxxx+++x+xxx++x+xxxx+++xx+xx++x++++x+++x+x+x++xx+++x++x+xxxxx+xxxxxx+++x+xxx++x+xxxx++xx+x+xx+xxxxxx+++xx+xx++xxxx+x++xx+xxx++x+xx+x++x++++xx+x+++x

  This is rather interesting, looking at these characters.
  I feel like this might be a pun...
  Like, I don't think it's just about how one of the characters (I think) caused a digit to be added and one to be multiplied (that seems to be what this is saying, right?)

  But I mean...
  I am suspecting that their reasoning for the choice of these characters
  (rather than "1" and "0")
  was the same as mine for the first iteration of this poem:
  to keep the language that is closest to the machine as representative of
  the physicality as possible.

  Something feels wrong about this... almost like I'm outing computers. Or like I'm advocating for some kind of bio-essentialism, which can be its own form of oppression. If she's a "O", she's a "O," no matter what she was assigned at birth. But also, do think that labelling these machine behaviors as "1" and "0" when there's no "off" really does cause a lot of problems; beyond evoking myths of genderism and settler colonial fantasies of "empty land," it's literally an inaccurate description of what is going on at the level of the machine. There is no "off."

  As I was ranting about over in the other thread, there's a weird type of Cold War era prudishness that led to gross mislabeling of so many things...Looks like machine language fell victim to this as well.

  But yeah, when I wrote my first iteration of this poem, I was picking different sizes of o's because I wanted to demonstrate how there is no "off" in a fully modern digital circuit. But the designers of that circuit picked x's to represent different levels of voltage...

  But "x" rotating on an axis.

  I am feeling some how chided by this.
  I had thought to pick characters based upon size, but it looks like the designers
  when they picked "x" and "+"
  (rather than "1" and "0")
  they were more thinking about....orientation.

  But also, there are the nicknames they assigned to the "x" and the "+", calling them "inclusive or" and "and."
  Sure, perhaps they were just grabbing on to words they'd heard in discussion of Boolean at that point.
  But also, the terms they picked both seem to imply a "here-ness."
  (I have reason to believe there might have been some puns at play)
  As if they are trying to emphasize a lack of absence.
  --There is no "off." Zero is a lie. And the terms "inclusive or" and "and" emphasize this.

  So, if we use the language of those who designed the first fully digital circuit,
  we would never say "ones and zeros" when talking about the stuff going on at the very base of the code--
  we'd say "and's and inclusive or's"

  Here's an iteration of the poem written that way:

  

  It goes on for 11 more pages.

  If you want to read the whole thing, it's here.

  I guess I should mention this binary poem I keep sharing and writing out differently is actually a found poem. To write it, I converted a passage I found meaningful from a Funambulist article into these closer-to-the-machine ways of repping the so-called binary. The part with the hyperlink is the word "radio." This poem touches on themes of love, identity, and technological mediation amidst settler colonial erasure.
• jeremydouglass

  February 20 edited February 28

  After reading "Recipe: Bittersweet Farewell Cake" and seeing the discussion of the related esolang Chef which turns recipe-formatted text into executable programs, I developed the following prompt:

  I will provide an experimental poem about queer grief, written in the format of a baking recipe. I would like you to plan to rewrite this poem into a program in the esoteric programming language "Chef", a stack-based language where programs look like cooking recipes. If possible the resulting Chef program should execute. Before rewriting the poem, please briefly explain what kind of output you are trying to create--what will your Chef program do when it runs, and why? The planned Chef program output should resonate with the original poem's theme of queer grief. Here is the source poem.

  ...but then, instead of giving it to an LLM such as ChatGPT, I gave the prompt to myself instead. As "you," I replied:

  Chef is a relatively low-level language that primarily manipulates individual letters and numbers (wet and dry ingredients) using verbose operations. This suggests that an adaptation of "Recipe: Bittersweet Farewell Cake" into an executable must have concise output in order to avoid making the code / recipe far too long. Given the focus on grief and memory, a meaningful output might be to print one or more significant observed dates, such as:

  • May 22 - Harvey Milk Day
  • June 28 - Stonewall Riots Anniversary
  • October - LGBT History Month

  An output might simply be "5/22" or "6/28" or "Oct". There might also be opportunities to use words like "Milk" in both contexts, or to assemble ingredients starting with L G B T Q A et cetera and build a string.
  However, any output from an executable remix of the original would be a new last line, and that last line might carry a lot of interpretive weight (e.g. implying that the poem in its entirety was about Stonewall or Harvey Milk, when it was not). Have you considered writing a new original queer code poem in Chef, rather than adapting an existing one?

  While queering LLM-interaction and (refusing) executability, I should note that in my experience giving a nuanced "no" is something that current popular LLM interfaces will almost never do--instead they tend to give either a safety-guardrails refusal or generate a best-effort token stream that attempts to complete the proposed task. I may have outed myself as human in my performed response by not making a best to fulfill the request, but instead exploring the request and questioning whether it should be fulfilled.
• Temkin

  February 21

  I've been thinking a lot about the undefined value in JavaScript. Undefined is what a variable holds when it doesn't yet have a value. Unlike many languages, JS does not throw an error when you use an undefined variable. And you can even do comparisons and calculations with undefined directly.

  undefined + 1
  

  This will give you the answer undefined. However, not everything undefined leads to more undefined. if you do a comparison:

  undefined == undefined
  

  This resolves to true. And if you add two truth values together like so:

  (undefined == undefined) + (undefined == undefined)
  

  You get the number two. JS converts the two "true"s to ones and adds them.

  This allows for a dialect of JavaScript that eschews the mention of any number, any string of text, any truth value, anything that we traditionally think of as data. All the data remains undefined, and yet can function as all these things: strings, ints, floats, everything else, while inscribed as the refusal to hold any specific value.

  So here is a piece that calculates five factorial (5! or 5 * 4 * 3 * 2 * 1) using only the undefined:

  var n = (undefined == undefined) + (undefined == undefined) + 
     (undefined == undefined) + (undefined == undefined) + (undefined == undefined);
  var output = (undefined == undefined + undefined) + (undefined == undefined);
  for (i = (undefined == undefined + undefined) + (undefined == undefined); 
        (i == n + (undefined == undefined)) == (undefined == undefined + undefined); 
        i = i + (undefined == undefined)) {
     var mult = (undefined == undefined + undefined) + (undefined == undefined + undefined);
     for (j = (undefined == undefined + undefined) + (undefined == undefined + undefined); 
        (j == i) == (undefined == undefined + undefined); 
        j = j + (undefined == undefined)) {
        mult = mult + output;
     }
     output = mult;
  }
  console.log(output);
  
• HarlinHayleySteele

  March 6

  @Temkin Oh! That's fun.
• HarlinHayleySteele

  March 6 edited March 6

  I think I've solved it! I think I've solved the mystery of the rotating 'x'!

  I mean, why did the original designers of the first fully modern computer circuit use "x" and "+" instead of "1" and "0" to talk about the machine's articulators (the physical stuff from which the code wafts)?

  Beyond all the suspected reasons I discussed earlier...

  Those reasons being:

  • There is no "off" (just two different voltage levels) so "zero" is a misnomer
  • Wiggy things about the way logic of that individual circuit was specified (Which is to say: choices that were made at a level a bit higher than what the machine itself was doing)
  • The desire to represent the two voltage levels using characters that showed they were different but equal ("x" and "+" do this much better than the utter lie that is "one/zero")

  Beyond these reasons, I think I found another reason, perhaps, that the MADDIDA inventors picked these two characters ("x" and "+")

  Why the heck were the MADDIDA inventors using "x" and "+" as their symbols for the spot where the machine meets the code?

  This might be kind of a stretch, and I have no way to prove it, but I think the choice of these characters might have been inspired by oscilloscope readings.

  Like, I picked "O"s to represent the voltage levels (rather than "1's" and "0's" for my first iteration of the poem, but that was before I read all this computer history stuff, and now, as I read these engineers talking about the design process of the first fully modern digital circuit, I'm realizing that these electrical currents at the base of everything had a texture to them (!) - they weren't smooth like an "0" - at least not when you're looking at them with an oscilloscope (!)

  As they lead engineer says (in this Smithsonian oral history interview), the oscilloscope shapes of electric currents can have "teeth" like "gears."

  To set the scene, the guy who eventually became the lead designer for MADDIDA was goofing around at his job at a weapons company one day, when he stumbled upon something fun...

  As he put it in an interview 30 years later:

  "This particular day I was certain nothing was going to work so I put a very elaborate pattern on the slope. By taking the digital voltage on both axes I got the equivalent of a figure-of-eight Lissajous pattern, only it had notches on it. On my scope it looked just like a pair of gears with teeth, and as the thing processed slowly, the gears would run one way and then run the other way. I put these wires around and stuck that on the scope. This set of people came through and stared at that in fascination..." (Mapstone Interview 1973, p. 6-7)

  So, basically he was playing around with electricity and watching it in an oscilloscope until he got a thing that sorta looked like a pattern. A "figure-of-eight Lissajous pattern."

  If you've never noodled around with an oscilloscope before, check out this neat video.

  

  ^ image is a screenshot from the video.

  Like, if you change the voltage level, you can get it to go more into this realm:

  

  And then into this realm:

  

  And so on.

  So the MADDIDA designer said what he was looking at looked like:

  • a "figure-of-eight Lissajous pattern"
    AND

  • "like a pair of gears with teeth"

  So maybe what he was looking at that day looked something like this:

  
  (image source: Mathworld)

  This shape seems to fit that description.
  (But it could have been another one...)
  I wonder what voltage level it would take to get you there?
  (I sure wish I had an oscilloscope of my own to play with right now...)

  Also in the interview passage he said:

  • "as the thing processed slowly, the gears would run one way and then run the other way"

  In the interview, he starts trying to build a wire around it, but then some kind of boss figure walked in and accidentally unplugged the whole thing. But perhaps...what he meant when he brought this up, is that this became the basis for what came to be the MADDIDA circuits that he designed later, if I'm reading between in the lines in this interview correctly.

  (There's no way I can confirm which shapes he picked from the two signals at the bottom of all code, not with out access to one of those machines. I sure wish I could fire a MADDIDA up and test this out...)

  So, anyway, where I'm going with this is I think perhaps there could be a 4th reason that the original designers of the first fully modern digital circuit picked "x" at different rotations (rather than the "o's" I picked) to represent what is going on at the machine-level of the code:

  • I figure that, of the characters that would have been available to them on a 1949 typewriter, two "x's" of different rotations ("x" and "+") might have best represented the texture of what was going on just below the machine language (voltage levels that looked like "gears with teeth") and also these characters might have represented the movement of those shapes on an oscilloscope reading (i.e., "the gears would run one way and then run the other").

  So, I think this design choice (the use of "x" and "+") was inspired directly by what was happening at the machine level...

  But...If they had had access to the full library of Unicode characters, based upon this description, I'll bet you a pretty penny they would have chosen "8" and "∞."

  So, if we write out the poem this way, this is what we get:

  You have permission to be yourself
  8∞8∞8∞888∞∞8∞8888∞∞88∞8∞8∞∞∞88∞88∞∞88∞8∞88∞88∞∞∞8∞∞∞88∞∞88∞888888∞∞8888∞8∞∞8∞∞∞888∞888888∞∞88∞8∞8∞∞∞∞8888∞∞∞88888∞∞88∞8∞8∞∞∞88∞88∞∞8∞88∞8∞∞8∞∞8∞8∞∞88∞8∞8∞∞8∞∞∞88∞∞∞8∞888∞∞8888∞8∞∞8∞∞8888∞888888∞∞8∞∞8∞8∞∞∞8∞8∞8∞∞∞88∞∞8∞∞8∞88∞8∞∞888∞∞88∞888888∞∞∞88∞∞8∞∞8∞∞∞∞8∞∞∞8∞8∞8∞∞8∞∞∞88∞∞88∞8888∞888888∞∞8888∞8∞∞∞88∞88∞∞∞8∞888∞∞8∞88∞8∞∞∞88∞∞8∞∞∞8∞8888∞888888∞∞888∞∞8∞∞8888∞8∞∞8∞∞888∞∞8∞∞888∞∞88∞8∞8∞∞88∞8888∞888888∞888∞888∞∞8∞88∞8∞∞∞88∞88∞∞8888∞8∞∞∞88∞888∞888888∞88∞8∞∞8∞∞8888∞8∞∞8∞∞888∞∞8888∞8∞∞∞88∞∞8∞∞8∞88888∞8∞∞8888∞888888∞∞∞8∞∞∞8∞∞8∞8888∞∞8∞∞∞∞88∞888888∞∞∞8∞∞∞8∞∞8∞∞∞∞8∞∞∞88∞88∞∞8∞8∞∞8∞∞88∞8∞8∞∞88∞8888∞888888∞∞8∞∞∞∞8∞∞8∞∞∞888∞888888∞∞8888∞88∞888888∞∞∞88∞∞8∞∞88∞8∞8∞∞∞888∞8∞∞∞8∞8∞8∞∞88∞8∞8∞∞8∞∞∞88∞∞888∞∞8∞∞88∞8∞88∞888888∞∞8∞∞∞∞8∞∞88∞∞888∞888888∞∞8∞88∞8∞∞8∞∞∞88∞∞∞8∞888∞∞88∞8∞8∞∞∞88∞88∞∞∞8∞∞88∞∞88∞8∞8∞∞8∞∞∞88∞∞∞8∞888∞∞8∞88∞8∞∞8∞∞∞∞8∞∞8∞∞∞88∞∞∞88∞∞88∞888888∞∞∞8∞888∞∞8∞8888∞∞8888∞8∞∞∞8∞8888∞888888∞∞∞8∞∞∞8∞∞88∞8∞8∞∞∞88∞88∞∞88∞8∞88∞888888∞∞8888∞8∞∞8∞∞888∞∞∞88∞∞8∞∞8∞∞∞∞88∞888888∞∞8∞88∞8∞∞8∞∞∞88∞∞∞88∞∞8∞∞∞88888∞∞8∞88∞8∞∞∞88∞88∞∞88∞8∞8∞∞88∞8888∞888888∞∞888∞88∞∞∞∞88∞88∞888888∞∞∞88∞88∞∞8888∞8∞∞88∞888∞∞8∞88∞8∞∞8∞∞∞∞88∞888888∞∞∞88888∞∞∞88∞88∞∞8∞∞∞∞8∞∞88∞∞∞8∞∞∞88∞88∞∞8888∞8∞∞8∞∞8∞8∞∞∞88∞∞88∞888888∞∞∞8∞888∞∞8∞8888∞∞8888∞8∞∞∞8∞8888∞888888∞∞∞8∞8∞8∞∞∞88∞∞8∞∞88∞8∞8∞∞88∞8888∞888888∞∞∞8∞888∞∞8∞∞∞∞88∞888888∞∞888∞88∞∞88∞8∞88∞888888∞∞88∞∞88∞∞8∞∞∞∞8∞∞∞8∞8∞8∞∞8∞∞∞88∞∞88∞8888∞888888∞∞8∞88∞8∞∞8∞∞∞888∞888888∞8∞88888∞∞8888∞8∞∞8∞∞888∞∞88∞8∞8∞∞∞88∞∞8∞∞∞8∞888∞∞8∞88∞8∞∞8∞∞∞88∞∞88∞8∞88∞8∞∞8888∞888888∞∞∞8∞∞∞8∞∞8∞8888∞∞88∞8∞8∞∞∞88∞88∞∞88∞8∞88∞888888∞∞8888∞8∞∞888∞∞8∞∞∞8∞888∞∞∞8∞8∞8∞∞8888∞8∞∞8∞∞888∞∞8∞∞888∞∞∞∞88∞88∞888888∞∞∞8∞888∞∞8∞8888∞∞88∞8∞88∞888888∞∞88∞∞88∞∞8888∞8∞∞8∞∞8∞8∞∞8∞88∞8∞∞8∞∞888∞∞8∞88∞8∞∞88∞8∞8∞∞∞88∞∞88∞888888∞∞8∞∞∞∞8∞∞88∞∞888∞888888∞∞∞88888∞∞∞88∞88∞∞8∞88∞8∞∞∞88∞∞8∞∞8∞∞∞∞8∞∞8∞∞∞88∞∞88∞8∞8∞∞∞88∞88∞∞∞88∞∞88∞888888∞∞∞8∞∞∞8∞∞8∞∞∞∞8∞∞∞8∞8∞8∞∞8∞∞888∞∞88∞8888∞888888∞∞∞88∞∞8∞∞∞88888∞∞88∞8∞8∞∞8888∞8∞∞8∞8∞∞88∞888888∞∞∞8∞888∞∞8∞∞∞∞88∞888888∞∞∞8∞888∞∞8∞8888∞∞88∞8∞88∞888888∞∞∞88888∞∞∞88∞88∞∞8∞88∞8∞∞∞88∞∞8∞∞8∞∞∞∞8∞∞8∞∞∞88∞∞88∞8∞8∞∞∞88∞88∞∞∞88∞∞88∞888888∞∞∞8∞888∞∞8∞8888∞∞∞88∞88∞∞8∞∞∞∞8∞∞∞8∞8∞8∞∞88∞∞∞8∞∞8∞88888∞888888∞∞∞8∞888∞∞8∞8888∞∞88∞8∞88∞888888∞∞∞88∞88∞∞8888∞8∞∞88∞888∞∞8∞88∞8∞∞8∞∞∞∞88∞8∞∞∞8

  Some quick caveats about how I'm doing this poem in general:

  • I mean, I realize that I'm jumping a couple levels in machine logic here, into the level below the machine language that sometimes gets called "microprogramming" (cf. Eckdahl et al 2003, p. 25). In this way, this poem, through catachresis, draws attention to the tension between what's going on at the level of the machine and the so-called machine language.
  • But I think by reifying the machine language that's like two levels removed from the physical machine and acting like the "0's" and "1's" are somehow physically essential (they aren't)(and this is what we all currently do when we teach this stuff), we really miss out on the full spectrum of possibilities that are actually afloat at this more material level...
  • Also, I suppose it might be obvious by now that I'm not translating boolean into MIDDADA logic here. Rather, it's that the MIDDADA circuits were severed from their original language and forced to learn Boolean (based on everything I can infer from Eckdal et al. 2003, and Mapstone 1977). And it's worth keeping in might that the MIDDADA-style circuits are still there, still at the basis of our machines, with all of us making hecka wrongful claims about that's physically there. I think claiming zero is an absence when there's actually something there is pretty gross, personally.

  • Also, I have to explain it all, otherwise everything I'm doing right now will miscatagorized due to the pervasive lies we tell about the "nature" of the machine. Queering is such a bespoke thing. Readymade categories, the privilege of, you don't get. (I wish we had more spaces in which people were invited to interact with these parts of the machine directly. This wouldn't be such a problem if that were the case.)

  It's really interesting how in the 1973 Smithsonian oral history interview, the MADDIDA lead designer seems mildly annoyed about the way the wrong terms keep being applied to his work. Like, in this passage, he says:

  "you take the voltage you wanted here, high-low, or true-false, whatever you wanted to call it, and write the equations with these things as input." (p.53).

  I mean, the way he says: "whatever you wanted to call it" (...am I detecting shade? 💅)

  I mean, throughout the interview, he really seems ambivalent to — and even annoyed by — the way people keep assigning value-laden symbols to the raw physics of the machine, symbols that just.... don’t match what is happening.

  And like, as we saw before, changing the voltage level results in different shapes; so calling one "bigger" than the other really doesn't make sense.
  He knew at the time (in the late 1940s when he wrote the AMC abstract) and he knew this during the Smithsonian interview around 30 years later.
  He's just rolling with these terms, these misnomers, because it's what the people who refuse to understand the physics seem to need. (I mean, there's really not that much to understand. child could figure this out in an afternoon with proper access.)

  But yeah, he's rolling with these term, with these misnomers ("high-low" "true-false") because he knows that's how other people are thinking of these things. But he never seems to let go of the fact that they don't really fit what's actually going on...
  This has me thinking of Dr. @edmondchang's concept of technonormativity (see: Chang 2021), which has sort of been a guiding light through all this. I mean...

  What is lost when we limit our self-expression based on the limits of other's expectations?
  (Y'all, I think microprogramming might be queer.)

  Also, it looks like the designer of the first fully modern digital circuit came up with a new type of mathematics that has no "zero" and also doesn't have integers, a mathematics that seems to have been designed to help people better understand what is going on at the level of the machine.

  I mean, check out this thing he said the Smithsonian computer oral history interview (note: he was likely showing the interviewer, Robina Mapstone, some things on his living room oscilloscope while he was saying this):

  "If you turn the things around in a circle and down here is the infinitesimal, the least significant place, where you have the most significance, if you cause them to overlap in a loop they close on themselves exactly and you now have a peculiar number that feeds from infinity, back to its infinitesimal self and that gives a system that among other things has no integers. You can get as close as you please to an integer, you cannot write a zero on it; you can get as close as you want to zero, but you can never reach it. So there’s no number more sacred than another. "

  ^(p. 38)

  "you cannot write a zero on it," says the guy who designed the first fully modern digital circuit. That about sums it up.

  Anyway, sorry for the blah, blah blah!

  But like, I think we've beyond a doubt confirmed that whatever the heck is going on at the level of the machine, it sure ain't "1" and "0" and the use of these terms erases what's actually going on.

  So, for the sake of the poem, it seems "∞" and "8" are probably actually the most accurate characters based on the spirit of the design of the first fully modern digital circuit, as described by its architect.

  Drawing upon the above passage from the interview with the architect, I am going to give these characters the following nicknames:

  ∞ = infinite self
  8 = infinitesimal self

  (If you need shorthand, maybe try: "nit" and "tes.")

  From this, we get two more iterations of the poem.

  The first one that starts out like this:

  

  ^ And it goes on like that for 16 more pages. (Here's the full version)

  And the second one starts out like this:

  

  ^ And it goes on for 5 more pages. Here's a link to the full version.

  But really, these terms are just slang for these characters: ∞/8

  And based on the words of those who designed the first fully modern digital circuit, this is probably what we should be calling the signals that can be found below all of the code, from which it wafts.