Autopoietic Turing Machine
Lucas Bang
Abstract
Autopoietic Turing Machine (ATM) is a kinetic sculpture featuring robotic hands that continuously type and edit their own controller source code. These self-programming hands modify the binary representation of a custom machine language, where every possible sequence of bits forms a valid state machine. Each finger movement and key press is driven by this state machine, which in turn is altered by the hands’ typing, creating a constantly evolving program for further self-modification. The design required overcoming interesting challenges, such as creating a robust yet expressive self-modifying language. The fingers, powered by solenoids similar to those in pinball machines, execute sharp, precise movements, producing a mechanical, rhythmic sound. ATM serves as a meditation on self-determination and the reflective feedback loop of a machine modifying its own behavior. By observing this system’s relentless, automated self-programming, viewers may question their own work practices and relationship with automation and expressivity, including the meaning and degree of self-agency that they find in automatable cognitive and embodied labor.
Introduction
Imagine you are editing a computer program. What is it like to be a programmer? Likely, you are mostly still and mentally focused with the exception typing fingers and saccadic eye movements. The characters that you decide to type next into your code editor and your subsequent thoughts are determined by your current internal mental state and whatever code you have read or written in the immediate vicinity of your cursor. At times, it can even be the case that (especially when coding in a statically typed pure functional language like Haskell) the code you have written so far fully determines the code you must write next in order to have a syntactically and semantically correct program (Wadler 1989). In fact, traditional program synthesis techniques (Cristina and Kroening 2017) and modern approaches based on large language models (Jiang et al. 2024) can fill in much of the code for you. While editing code these days, we operate within a cybernetic systems of body, mind, code, and prediction algorithms (Hayles 2008; Penny 2017).
In this paper, I describe how I have taken the experience of programming as just described, reduced it to its core features, and built a robotic system that programs itself. This interdisciplinary project Autopoietic Turing Machine (ATM) is a reflection on the labor of programming—especially in the time of AI-driven code-synthesis—and the phenomenological experience of editing code. I describe my design of a pair of robotic hands that continuously type, and thereby edit, their own controller source code. These 3D-printed hands program themselves by directly editing the binary representation of a carefully constructed machine language where every possible sequence of bits encodes a valid state machine. Every finger movement, and therefore every key press, is controlled by that state machine, which, when edited by said key-presses, results in a different program for further self-programming.
This paper focuses on two aspects of this work: (1) the design, implementation, and limitations of the robotics and accompanying peripherals, and (2) the artwork as a meditation on the experience of programming.
As a robotic design, construction of Autopoietic Turing Machine required solving several challenges. The self-modifying machine language required balancing expressivity against robustness to perturbation. A custom minimal keyboard–capable of sending only signals for moving a pointer through memory (↑,↓,←,→) and bits (0, 1)–was designed iteratively in tandem with hand movements so that artificial hands and keyboard can function together. Further, pinball machine solenoids drive the fingers, resulting in sharp, precise movements and a clockwork-like soundscape.
As an artwork, ATM invites the viewer to consider the ostensibly paradoxical, yet internally consistent, cybernetic-reflective feedback loop of a system that manually edits its own behavior, along with its distinctive anachronistic visual design and striking soundscape. By reflecting on machinic capacity for (lack of) self-determination, the viewer may consider their own agency. For those familiar with programming or not, they may ask themselves “what meaning can we find in our own work practices when we observe a system mindlessly churning away on programming itself?”
Background
The title of the work, Autopoietic Turing Machine, deserves some explanation. The word autopoetic comes from the Greek words auto (self) and poiesis (making, or construction). As this artwork is a system that constantly reconstructs itself, I borrowed the word autopoietic from the work of Chilean biologists Varela and Maturana who introduced the concept of autopoiesis to describe systems that are self-creating and self-maintaining through continuous regeneration of their own components and processes (Maturana and Varela 1991):
“An autopoietic machine is a machine organized (defined as a unity) as a network of processes of production (transformation and destruction) of components which: (i) through their interactions and transformations continuously regenerate and realize the network of processes (relations) that produced them; and (ii) constitute it (the machine) as a concrete unity in space in which they (the components) exist by specifying the topological domain of its realization as such a network.”
Next, ATM connects to the work of Alan Turing in two ways. First through Turing’s pioneering work on the theory of computation, specifically his creation of the Turing machine–an abstract machine used to model computation (Turing 1936). A Turing machine operates using an infinite tape and a head that reads and writes symbols, simulating any computer algorithm. However, no real-world computational system has infinite memory, so for ATM I implemented a finite version. ATM is functionally equivalent to a Turing machine, with the realistic constraint of finite memory.
The second connection relates to the Turing Test (Turing 1950). Turing proposed that to determine whether a machine is intelligent, one should interact with it through a purely textual interface to prevent revealing any physical characteristics: “The ideal arrangement is to have a teleprinter communicating between the two rooms”. This positioned typing and the keyboard as the central interface for communication in assessing intelligence. Similarly, in ATM, the keyboard plays a central role, with the system effectively communicating with itself through typing. This project emphasizes the act of typing as a critical mechanism for interaction, while avoiding abstracting away the physical embodiment of the machine and focusing on cognition as disembodied.
Though not directly a paper about intelligence, Turing also highlighted the physical and cognitive aspects of computation when developing the Turing machine. He envisioned a human performing computations: a person would work on a piece of paper, writing symbols in a finite space. He suggested dividing the paper into cells, with only a limited number of symbols that can fit into each cell, constrained by the physical space and the resolution of human handwriting. The person would then move around the paper, considering the written symbols, their mental state, and memory before adding more symbols. This process of human computation inspired Turing’s formal description of the Turing machine.One might wish to compare this description of computing by hand to the description of programming that opened this paper.
Turing later demonstrated, using the concept of self-reference, that attempting to create a Turing machine capable of determining whether another Turing machine would halt leads to a paradox showing that some problems are fundamentally uncomputable. Researchers like Soare, Wadler, and Sieg noted that Turing’s inclusion of the embodied, physical aspects of human computation distinguished his work from that of contemporaries like Emil Post, Alonzo Church, and Kurt Gödel, who also produced important impossibility results in mathematics. Soare, Wadler, and Sieg argued that it was Turing’s attention to the human experience–working by hand, with brain and body–that made his work more influential and compelling, helping it gain broader recognition (Soare 1996; Wadler 2015; Sieg, Szabó, and Mclaughlin 2016).
WIth this background in mind, I will discuss the design of Autopoietic Turing Machine and comment on its relationship to existing robotic artworks, fiction, media theory, and HCI.
Design Details
Overall Architecture
ATM is constructed from several interconnected subsystems (Figure 2). These subsystems form a feedback loop. A pair of hands press on keys on a custom keyboard. Those key presses are interpreted by an Arduino micro-controller. Depending on the Arduino signal, the result is to set the bit at the memory pointer to 0 or 1 or move the pointer in one of four directions (↑,↓,←,→). The bits in memory are a machine encoding of a custom assembly-like language for specifying a state machine (i.e. transducer). The state machine reads the bit value at a memory pointer (which has just been updated) and drives a set of relays to trigger more key presses from the hands, continuing the cycle. Finally, though not part of the control loop, the current state and outputs of the transducer, the raw memory bits, and the equivalent decoded program are displayed on a transparent LCD display that rests elevated just above the hands.
Articulated Hands
The artificial hands were 3D printed (Figure 3, top). The design is known as “Jointed Hand” by BQEducación who “develop[s] products, solutions and technological projects that feed the creative, technical and emotional skills of people” (BQEducación). The files are freely available from Thingiverse (Jointed Hand). I used this design under the Creative Commons Attribution Share Alike License 3.0 (License) with no modification to design. After 3D printing, I modified the hands, including sanding, painting, drilling, and gluing of various interfacing components. Finger movements are coordinated by a set of relays, solenoids, and high-tensile wire. The relays are contained in a standard home-automation 8-Channel 5V USB control module, controlled via a Python-based USB relay human interface design (HID) (HID Library) The solenoids are rapid-fire linear actuators similar to those used in pinball machines. When powered, a solenoid pulls a wire threaded through hands to fingertips, forcing it to contract and strike a key.
Keyboard
The keyboard on which the hands type is a custom design consisting of only six keys: ↑,↓,←,→,0, and 1 (Figure 3, bottom) Key placement and small modifications were made to the hands were designed to optimize for the fingers to strike directly down on the keys (Figure 3, right). The keyboard plates were CNC-ed from stainless steel. The key switches are off-the-shelf Cherry MX Blue switches. The six switches are wired to an Arduino micro-controller which converts them into signals—e.g. move the current memory pointer to the next memory block (↓) or set the bit located at the current memory pointer to 1.
State Machine
Hand movement is controlled by a state machine. The state machine is stored in memory. When the hands press arrow keys, the address of a memory pointer is updated, and when the 0 or 1 keys are pressed, the bit located at the address of the pointer is set accordingly. Consequently, the state machine itself is changed. Here we describe the operation of that state machine using terminology and notation inspired by standard reference text on the theory of computation and state machines (Sipser 2006; Roche and Schabes 1997). Technically speaking, the state machine in question is a transducer which outputs 0’s and 1’s. For the purposes of ATM, I consider finite a finite-state transducer T to be a tuple (Q,Σ,Γ,δ) such that:
Q is a finite set of states,
Σ is a finite set called the alphabet,
A is a set of actions,
δ ⊆ Q × Σ × Σ × A × Q is a transition relation.
The pair (Q,δ) can be thought of as defining the transition graph of T where Q is the set of vertices and directed edges are determined by δ. For (q,u,v,a,r) ∈ δ we define an edge going from vertex q to vertex r labelled with the current input (alphabet symbol being read) u, the corresponding output (alphabet symbol to write) v, and the action a. For ATM, the alphabet Σ is simply {0, 1}, Q is a set of numbered states {0, …, n}, A is {↑,↓,←, → } (pointer / cursor control),programming / machine language implemented in Python.
State Machine Controller Programming Language
| Keyword | Argument | Domain | Semantics |
|---|---|---|---|
goto |
n | {0…2k − 1} | set next state to n |
move |
m | {↑,↓,←, → } | move cursor in direction m |
type |
t | {0, 1} | write symbol t at cursor |
The custom controller language is based on an encoding of Turing
machine instructions. The human-readable translation of the controller
code has 3 keywords: goto, read, and
type, with semantics given in Table 1. The human-readable version
of the code is not necessary, but provided for the benefit of the
human observer. From the machine’s point of view, a rule specifying a
state transition relation is a sequence of 16 bits. ATM uses
5 bits of state, for a total of 32
possible states in a given transducer. The number 5 was chosen for
aesthetic purposes in the final display of raw mempry. The first 8
bits describe what to do if the machine is currently reading a 0, and the second 8 bits determine the
actions and outputs if the cursor is currently on a 0. As there are four directions, each is
encoded using 2 bits (00 for ↑, 01 for
↓ etc.). A machine “word” might look
something like below (extra spaces added to aid the reader).
1 00 11010 0 01 00100.
If these bits are at word address 01101 (state 13), this tells the machine
that if in state 13 and reading a 0
then type 1 move up goto state 26 and else if reading a
1 then
type 0 move down goto state 8.
Transparent Video Display Overlay
Above the hands is a transparent LCD video display (Figure 4). The display was constructed from a monitor by extracting the LCD panel and removing the anti-glare film. This adds to the aesthetic of the sculpture by inverting the usual physical relationship between hands and code.
Enclosure
The enclosure was constructed using standard woodworking techniques. It started as a raw walnut block which I milled, jointed, and planed. Panels were constructed and used to create a box to house all components. The visual effect is that of a mid-century modern stereo cabinet, giving an anachronistic, vintage science-fiction feel to the completed sculpture. See Figure 5 for design and image of ATM on display at Virginia Tech’s Moss Art Center, featured in the gallery component of the 2022 Future Bodies Symposium.
Discussion: Robotic Expressivity
Inspired by work on measuring the expressvity of natural and
robotic systems (LaViers 2017), I provide a
combinatorial analysis of ATM. Let k be the number of bits used to
represent a state. For every state, the machine requires a
specification of which state to transition to, what to write in its
memory (the tape) at the current cursor position, and where in memory
(the tape) to move to next. Each of these things must be specified for
the cases when the cursor is currently at (reading) a 0
or 1. Thus, for each possible read-bit (0 or 1)
there must be 1 bit for what to
write, 2 bits for which direction to
move among 4 possibilities, and k bits for the state to transition
to next, for a total of 2(1+2+k) = 2k + 6 bits
for every state transition. With k bits it is possible to represent
2k states, and so
the entire encoding of the machine requires 2k(2k+6) bits.
Consequently, the memory of the Turing machine is designed to be a
k-bit addressable space with
2k + 6 bits per address.
There are N = 22k(2k+6) possible memory states for this machine overall. For ATM, k = 5, and so there are approximately N = 1.340 × 10154 possible memory states. For comparison, there are thought to be 1080 atoms in the universe. Since each memory snapshot can be interpreted as the encoding of a specific transducer, one may interpret this system as walking through N different state machines. Alternatively, one may thing of this as one giant state machine with N states. The operation of ATM is a walk through all possible state machines it can represent. This is like trying to find a book in Borges’s Library of Babel (Borges 1941), but where each book tells you which page of which book you need to look at next. The limited repertoire of ATM (6 key presses), still allows for an unfathomable number of programmable behaviors. On the other hand, the individual behaviors themselves are severely limited and simple.
An important source of expressivity comes from the physicality of the machine. Much like a human typist using imperfect tools, occasional mistakes happen: A key is not fully pressed and a bit fails to be updated, or a key sticks and an extra pointer update is made. Despite being controlled by a cleanly formalized deterministic finite state transducer, the physical limitations and inconsistencies of physical construction add variation and fluctuations in behavior.
Discussion: Artwork Context
As no artwork exists in a vacuum, I’d like to place Autopoietic Turing Machine into context.
Robotic Works
An early form of mechanized typing was the teletype, or teleprinter, which converted control signals into electromechanical movements of typewriter keys. These devices became key interfaces for mainframe computers, where users typed commands and received responses. The teletype serves as a historical precursor to the concepts explored in ATM. As a teletype converts signals into keystrokes, ATM transforms its internal state into physical actions, recursively modifying its own program. Both systems blur the line between human input and machine output, but while the teletype enabled human-computer interaction, ATM automates the process entirely, emphasizing the machine’s self-referential autonomy and the evolution of mechanized labor and computation in mediating human interaction with technology.
The earliest record of a functioning typing robot that I can find is from 1987. That year algorithmic trading pioneer Thomas Peterffy had rigged up the first fully automated trading system by directly wiring an IBM personal computer and custom circuits into a hacked Nasdaq terminal (Steiner 2012). Peterffy was told by a regulator that he could not alter Nasdaq terminals, and that “all orders need to go through the keyboard, typed one by one”. So, he built a computer vision system to read the terminal screen and a typing robot to enter the trades. He made $25 million that year and is now a billionaire.
From 17th century textile workers sabotaging knitting machines (Rudé 1964) to today’s worries over generative AI corroding critical thinking skills (Zhai, Wibowo, and Li 2024), a tension between the primacy of human accountability and agency and the automating of personal mental and physical effort has existed since before the industrial revolution. Peterffy’s cybernetic trading contraption seems to have hit upon this nerve within the Nasdaq regulators. ATM parallels Peterffy’s machine by highlighting the tension between human agency and machine automation. Both systems automate tasks traditionally performed by humans–Peterffy’s robot circumvented Nasdaq’s manual input requirements, while ATM self-modifies without human intervention, echoing broader concerns about the erosion of human accountability and cognitive effort in favor of mechanized processes, inviting reflection on the evolving relationship between humans, machines, and mental labor.
Creative Works
ATM is inspired by real and imagined robots that play with self-reference, automation, and futility. The simplest device that robotically manifests self-interaction is sometimes referred to as a Useless Box. This novelty item is a box with a switch. Turning the switch to the on position activates a small mechanical arm that comes out of the box and turns the switch off. In a sense, this is a finite state transducer that operates similarly to ATM with one a single bit of state and a constant transition relation.
Much more sophisticated is Can’t Help Myself by Sun Yuan and Peng Yu which features a robot arm programmed to reclaim its hydraulic fluid that constantly leaks using a squeegee, representing a futile struggle for survival (Yuan and Yu 2016). The robot ultimately died in 2019 symbolizing a relentless and pointless battle against its own fate.
Arthur Ganson’s Machine With Oil is a kinetic sculpture made of machined gears, cams, and linkages (Ganson, n.d.). This work cyclically carries a trough at the end of a metallic arm to dip it in oil and then rotate the trough to lubricate all of its interconnected mechanisms.
The Useless Box, Can’t Help Myself, and Machine With Oil each represent different expressions of self-interacting machines, from playful absurdity to existential futility. In relation to ATM, these works explore themes of self-modification, automation, and purposeless cycles. Like the Useless Box, ATM is a self-contained system with a finite set of states, endlessly performing an action that may seem futile. ATM also engages with deeper questions about autonomy and labor, similar to Can’t Help Myself, as it perpetually rewrites its own programming in a recursive loop. Machine With Oil offers a metaphor for ATM’s recursive self-maintenance, emphasizing the cyclical, mechanical nature of self-preservation, even when divorced from human intent or intervention. These works collectively resonate with the theme repetitive, autonomous tasks, blurring the lines between purpose and futility, creation and destruction.
In the now classic 1995 Japanese cyberpunk film Ghost in the Shell (Oshii 1995), a cyborg character needs to interact quickly with a computer system. Despite having computational enhancements, their default interaction is still via keyboard. However, in order to increase the rate of information transmission, they expand each of their fingers into three smaller robotic tendrils, for a total of 30 fingers. In Ted Chiang’s short story Exhalation, the robotic protagonist becomes interested in their own physical and mental functioning, along with their own mortality (Chiang 2014). Using an intricate system of prisms and linkages (a “solipsistic periscope”), they are able to view the back of their own head, open it up, and investigate the operation of their own mind, at one point worrying if they have changed their own thinking by tempering with their own mechanical brain.
Both Ghost in the Shell and Exhalation explore themes of self-awareness and the mechanization of the body, which directly relate to ATM. In Ghost in the Shell, the cyborg character’s reliance on the keyboard, despite advanced enhancements, highlights the continued importance of embodied interaction with machines–a theme central to ATM as it types and modifies its own code. Similarly, in Exhalation, the robotic protagonist’s introspection and self-modification mirror ATM’s recursive self-editing process, as both systems grapple with the implications of autonomy and self-awareness. These works engage with the tension between mechanized cognition and physical embodiment, a tension that ATM manifests through its autonomous typing hands.
Strange Loops
The Autopoietic Turing Machine draws on themes of feedback loops, which have long been a source of artistic exploration into the absurdity and complexity of computation (Hofstadter 2007). Artists like M.C. Escher, known for his recursive and paradoxical structures like hands that draw themselves (Locher 1989), explored the concept of strange loops, where moving through different layers of a system eventually brings one back to the starting point. In a similar vein, Gödel, Escher, Bach by Hofstadter unravels how self-reference and recursion–concepts central to the machine’s design–are embedded in the foundations of logic, mathematics, and art (Hofstadter 1979). These strange loops blur the lines between system and observer, resonating with Gödel’s incompleteness theorems (Gödel 1931) and Turing’s work on computability, both of which highlight the limitations of formal systems when applied to self-referential structures. ATM plays with these themes by embodying self-reference in a physical form, typing its own source code in a recursive loop that mirrors the paradoxes found in programming languages, computability theory, and formal systems. Through its relentless self-modification, ATM enacts a meditation on the limits and potential of self-referential systems in art and computation.
Media-Cultural Considerations
Media studies as a field investigates how human experience is mediated through communication technologies (McLuhan 1964). While traditionally focused on mass media (e.g., television, radio, film), the scope has expanded to include technologies like the internet, social media, and computer code. One of the most famousquotes in media studies states (Jouhki and Hurme 2017): “We become what we behold. We shape our tools and then our tools shape us.”
This quote reflects how technology simultaneously expands and constrains human potential for progress. Each new communication technology–writing, printing, telegraphs, typewriters, the internet, ChatGPT, and so on–opens up new possibilities but eventually solidifies into a static foundation for future advancements. In ATM, I have reinterpreted this concept into a self-referential, recursive mechanical system: a tool that shapes its own behavior as it navigates an unfathomably vast number of potential programs. This sculpture invites the viewer to contemplate the paradoxical yet internally consistent cybernetic feedback loop of a system that continuously reshapes itself using familiar tools.
Going further into the theory behind this work, ATM draws upon media theoretic writings to provoke contemplation about computing, labor, and embodiment. In Discourse Networks 1800/1900, Kittler provides a critical analysis of the complex interplay between the shifting gender dynamics in early 20th-century U.S. and the invention of the typewriter. While typewriting was presented as a vehicle of liberation, allowing women to exchange embodied labor for money, in practice, typewriter operators–typically women–were reduced to mere transducers within socio-electro-mechanical systems. Typing became mechanized labor, as operators functioned as the “central relay station of an immense information network,” cashing in on their perceived “nimble fingers [and] enforced attention to the small” as observed in Donna Haraway’s Cyborg Manifesto (Haraway 1991). ATM engages with these themes of mechanization and the embodiment of cognitive processes. Haraway critiques how technology blurs the boundaries between human and machine, with an emphasis on embodied aspects. In ATM, the robotic hands, much like Kittler’s automatized typewriter operators, ceaselessly edit their own controller source code. Through this automated process, they become both the creators and subjects of their labor, reflecting the tension between human agency and automation. By focusing on the act of typing and recursive self-modification, ATM extends Haraway’s critique, encouraging viewers to reflect on their relationship with automation and labor in a world where machines increasingly embody cognitive functions. The system mirrors a limited form of self-awareness through physical, yet disembodied, actions, embodying the blurred lines between human autonomy and automatic processes.
Cognition, Programming, and Robotics
A key theoretical foundation for this project relates to concepts of cognition, phenomenology, and embodied cognition. Drawing from Understanding Computers and Cognition: A New Foundation for Design by Winograd and Flores, their discussion of phenomenology and Heidegger’s distinction between present-at-hand and ready-to-hand provides a useful lens for understanding the interaction between humans and tools. Heidegger’s notion of present-at-hand describes an observational attitude, often adopted by scientists or theorists, in which the observer focuses on the objective properties of an object, removed from practical use. In contrast, ready-to-hand refers to a more embodied state of interaction, where a tool, such as a hammer, becomes seamlessly integrated into the user’s activity without conscious attention. The tool, in this state, functions as an extension of the body, facilitating action without reflection. Winograd and Flores apply this Heideggerian framework to human-computer interaction, using the example of a text editing program. When a user is deeply focused on writing, the software, keyboard, and interface become ready-to-hand, operating smoothly and unobtrusively within the user’s cognitive and physical workflow. However, when the system fails–such as a software bug–the user is forced into a present-at-hand mode, in which they must reflect on the tool itself, interrupting the flow of work to troubleshoot or navigate menus.
In constructing Autopoietic Turing Machine, I experienced a phenomenological paradoxical duality between embodied action and reflective cognition. A significant amount of care and labor was invested in building the machine’s external enclosure, particularly the physical tasks of woodworking and assembly. This process required a deeply embodied cognitive experience, as I used my body to perform tasks such as cutting wood, hammering, and assembling components. The effort put into ensuring the system’s physical protection highlights the contrast between the labor-intensive creation process and the machine’s eventual autonomous operation. Once completed, ATM functions independently, continuously programming itself. This recursive self-operation echoes the Heideggerian distinction, as my embodied effort created a system that, once operational, becomes ready-to-hand while my engagement with its construction was very much a present-at-hand experience of deliberate, reflective labor.
Conclusion
Autopoietic Turing Machine serves as an exploration of self-modification, feedback loops, and the intersection of human and machine labor. By engaging with themes of recursion and embodiment, it invites reflection on the evolving relationship between humans, machines, and the processes that define both cognition and creation.
Acknowledgments
This project would not have been possible without the support of the Harvey Mudd College Hixon-Riggs Program for Responsive Science and Engineering, the Harvey Mudd College Maker Space, and the Chaffey Continuing Education Program course on woodworking and carpentry.