Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

2024 Participants: Hannah Ackermans * Sara Alsherif * Leonardo Aranda * Brian Arechiga * Jonathan Armoza * Stephanie E. August * Martin Bartelmus * Patsy Baudoin * Liat Berdugo * David Berry * Jason Boyd * Kevin Brock * Evan Buswell * Claire Carroll * John Cayley * Slavica Ceperkovic * Edmond Chang * Sarah Ciston * Lyr Colin * Daniel Cox * Christina Cuneo * Orla Delaney * Pierre Depaz * Ranjodh Singh Dhaliwal * Koundinya Dhulipalla * Samuel DiBella * Craig Dietrich * Quinn Dombrowski * Kevin Driscoll * Lai-Tze Fan * Max Feinstein * Meredith Finkelstein * Leonardo Flores * Cyril Focht * Gwen Foo * Federica Frabetti * Jordan Freitas * Erika FülöP * Sam Goree * Gulsen Guler * Anthony Hay * SHAWNÉ MICHAELAIN HOLLOWAY * Brendan Howell * Minh Hua * Amira Jarmakani * Dennis Jerz * Joey Jones * Ted Kafala * Titaÿna Kauffmann-Will * Darius Kazemi * andrea kim * Joey King * Ryan Leach * cynthia li * Judy Malloy * Zachary Mann * Marian Mazzone * Chris McGuinness * Yasemin Melek * Pablo Miranda Carranza * Jarah Moesch * Matt Nish-Lapidus * Yoehan Oh * Steven Oscherwitz * Stefano Penge * Marta Pérez-Campos * Jan-Christian Petersen * gripp prime * Rita Raley * Nicholas Raphael * Arpita Rathod * Amit Ray * Thorsten Ries * Abby Rinaldi * Mark Sample * Valérie Schafer * Carly Schnitzler * Arthur Schwarz * Lyle Skains * Rory Solomon * Winnie Soon * Harlin/Hayley Steele * Marylyn Tan * Daniel Temkin * Murielle Sandra Tiako Djomatchoua * Anna Tito * Introna Tommie * Fereshteh Toosi * Paige Treebridge * Lee Tusman * Joris J.van Zundert * Annette Vee * Dan Verständig * Yohanna Waliya * Shu Wan * Peggy WEIL * Jacque Wernimont * Katherine Yang * Zach Whalen * Elea Zhong * TengChao Zhou
CCSWG 2024 is coordinated by Lyr Colin (USC), Andrea Kim (USC), Elea Zhong (USC), Zachary Mann (USC), Jeremy Douglass (UCSB), and Mark C. Marino (USC) . Sponsored by the Humanities and Critical Code Studies Lab (USC), and the Digital Arts and Humanities Commons (UCSB).

[PRACTICE] Queer Code Poetry Jam

To close out the week, we invite everyone to submit their own queer code poem! Drawing inspiration from our [PROMPT] and [PROCESS] discussions, how might your own creation address queer code, embodied code, nonnormative identities and desires, and radical technologies?

Here's a short BASIC code poem that I had ChatGPT generate for me; even after a few permutations, the result isn't particularly great, but still very interesting to look at:

10 REM The Man and His Lost Love
20 LET vows$ = "whispered"
30 LET light$ = "tender"
40 LET loss = TRUE
50 LET wander = TRUE
60 LET echo = TRUE
70 LET darkestNight = TRUE
80 LET husband$ = "loving"
90 IF loss THEN PRINT "In shadows cast by veils of " + light$ + " love's embrace,"
100 IF wander THEN PRINT "A man once held in " + vows$ + " arms of gentle grace,"
110 IF echo THEN PRINT "As echoes of his love in silence calls,"
120 IF darkestNight THEN PRINT "Their love, a beacon in the darkest night,"
130 PRINT "His husband's love guides him, a beacon through."

Comments

  • 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.

  • @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!

  • 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.

  • 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.

  • @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.

  • @Temkin: That's very cool!

  • @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!

  • @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.

  • @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.

  • 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.

  • @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).

  • 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.

  • 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.

  • edited February 14

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

  • 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

  • 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...

  • 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.

  • edited February 18

    @markcmarino I wonder if you could add a link to the video of Friday's discussion to your comment? 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, I feel like the knowledge about 3rd, 4th, and 27th genders is constantly being stolen from us, and that 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 as Miss. Frizzle 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.

  • edited February 20

    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 the Maddida.
    Maddida fully transitioned.

    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 fully modern base-2 computer didn't use "1" or "0" at all to talk about their machine (at least not as they were launching it). Instead they used these symbols:

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

    And at first when I saw this in their abstract, I was super confused.

    Like, "inclusive or" and "and" show up as technical terms in Boolean, sure.

    But the way the designers are using the terms in the abstracts seem rather different. After thinking about this for a while, I think they are using the terms as nicknames for these symbols.

    I'm going to assume, though, based on what I'm seeing in the specs in this IEEE article, and in their abstract on pages 17-18, that they were using "x" and "+" rather than a "1" and "0."

    So...
    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 its first layer that wafts up from 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.
    I can only assume that their intention was the same as mine:
    to keep the language that is closest to the machine as representative of
    it 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 for of oppression just as bad as bio-essentialism. 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."

    Anyway...
    I find it interesting that it seems like my intuition when coming up with my first iteration of the poem ended up perhaps matching the way the original designers were talking about the machine things from which the code wafts.

    I was picking different sizes of o's.
    But they picked x's. Why x's?
    As its builders, they were obviously closer to the machine than I.
    What made them think it was a good idea to pick x's to represent different levels of voltage? Why not pick characters of differing sizes?

    I mean...
    My way of offering a some physicality-based symbols to represent what's going with code at the level of the machine is based on size.
    But the OG designer's approach seems to be about ....orientation.

    -

    But also, another way they labeled these characters (that get mis-labelled as "1" and "0" today) is with what I think are nicknames they assigned to the "x" and the "+", calling them "inclusive or" and "and." (I think they were just grabbing on to words they'd heard in Boolean at that point). But also, the terms they picked both seem to imply a "here-ness." As if they are trying to emphasize a lack of absence. (There is no "off." Zero is a lie.)

    So, let's say I want to write my binary poem using the nicknames they applied to the things that today we wrongly call "1" and "0":

    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 and technological mediation amidst settler colonial erasure.

  • edited February 20

    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?

  • 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);
    
Sign In or Register to comment.