TAU-800B Super

(Adapted from the corresponding Twitter thread, which has a lot more visual aid.)

Last week, me and a friend (André Duarte) presented an art instalation for the processing Community Day Coimbra 2021.

It's titled TAU-800B.

We put a ton of thought and ideas into it, so I'll be going over them here!

But first, a TL;DR:

TAU-800B approaches the theme of Anachronism in many ways, some literal and some figurative. It is a full emulation of a time traveling computer, that despite having that ability and sporting a retrofuturistic interface, obeys computing paradigms of the 70s.

These strange internals (6 bit words, 6 word stack, assembly only) are fully exposed for the viewer that takes a closer look. Keeping with the 70s theme, there's also a complete reference manual next to the screen, providing further hints on the nature of the artifact.

(If you'd rather hear me talk much too fast, me and André gave a 10 minute talk on the piece as part of the exhibition; 2h mark.)

(we had to rush a little though, so I'm hoping to get into more detail here.)

So, the theme for the call was "Anachronism". That's a term that refers to inconsistencies related to time, like a knight welding a gun, or European Middle-Ages peasants eating potatoes. Think steampunk.

As a word, Anachronism has Greek roots, "ana" + "chronos", or "against" + "time".

We knew from the start that we wanted to explore this meaning figuratively and literally.

On the other hand, Processing is all about computational creativity and integrating code in your art.

Computers against time.

Computers disobeying time.

Time-traveling computers?

This drove us early to the core concept of TAU-800B: a time-travel assisted computer, that would mix old (like, minicomputer old) architecture and I/O with a futuristic interface.

This concept had some nice features:

1. It allowed us to explore both literal and figurative senses of the theme, by incorporating both time-traveling and tech asthetics from multiple eras

2. It gave us a free pass to get some things wrong/too modern; it's an anachronistic artifact after all!

3. It gave a lot of space to create a narrative and an interaction with the audience, in the presentation of the machine to the audience.

4. Lots of cool programming!

We began, then, attacking this concept in multiple fronts: we designed a mockup for the interface, and began writing a reference for the machine's assembly, bringing in ideas for the latter from all of x86, 6502 and Z80A!

You can see also here the first mockup for the interface versus the final one. The core elements (shown state and size details) never changed!

(We featured a clock in the center from the start, given the time theme, and as a way to later do meaningful I/O.)

Another running theme, visual-wise, was the japonese retro-future asthetic. I recently watched Neon Genesis Evangelion, and if there's one thing EVA nails, it's the computer interfaces. On the other hand, it was a further nod to the theme, by using the 90s standard of futuristic rather than a more modern one.

But what does "time-traveling assisted computer" even mean, I hear you ask? (maybe. humor me.)

Well, both me and André are physicists working in computer science, and it turns out that this is a sufficiently serious question that smart people have thought about it.

In particular, consider the Novikov Self-Consistency Principle. It's basically the stance that you have to consider time as a whole, so that paradoxes are impossible, because things have to make sense, well, as a whole.

(Yes, it's the timey-wimey thing.)

This turns out to have some interesting consequences for computation:

Consider a computer equiped with a kill-switch, and a time machine. Now give it some really hard problem, and instructions to do the following: first, to guess an answer to the problem. Then, if it gets it wrong, to go back a moment in time and activate the kill-switch.

Because getting it wrong would induce a paradox, then, physically, it must guess correctly! Congratulations, your machine now has infinite computing power.

Our particular take on this sort of time travel ability is that the TAU can write values to its registers at past and future moments.

Of course, seeing that we wanted to emulate the machine, this could've posed some problems. That's where the 70s limitations we imposed came in handy.

As you might know from studying dynamical systems, if you have some transformation (say, from a machine state at a given moment to the state in the next), that transformation might have what's called a "fixed point": a state that's essentially not affected by the transformation.

In particular, a consistent universe (i.e. sequence of machine states) must be a fixed point of the program that the machine is running.

Because the RAM was so small, we could actually keep track of its state throughout a large window of time (say, 500 instruction steps). So, when we found a temporal addressing, we tried to converge towards a fixed point by repeatedly simulating the universe.

(Note also that this scheme isn't perfect, there's a lot of ways in which it can fail: unstable fixed points, interweaving time addressing... But shh, we're the ones writing the programs to be ran!)

(A way this *does* work, however, is in fast-tracking Newton's method 👀)

You need to carry out the above process really fast, so that it looks effectively instantaneous. A convenient segway to discuss the tech we used!

The actual display is driven by electron, because web is super portable, and we weren't sure how the installation would be displayed (aspect-ratio wise, etc.)

However, like I've just said, we needed to be fast, so the whole backend (parsing, emulation) was written in Rust!

We wanted as little computation to be done on the web side as possible (to save time), so all Electron does is poll for state updates, and show the current internal state of the machine.

Here's the diagramme we were using during development:

							 Backend

							 ┌─────┐
							 │Start│
							 └──┬──┘
						 ┌──────────┴────────────┐
					   ┌─────┤ Threaded poll response├──┐
					   │     │     and processing    │  │
	    Frontend                       │     └───────────────────────┘  │
					   │                                │
	     ┌─────┐                       │                       ┌────────┴───────┐
	     │Start│                       │                       │Begin processing├───┐
	     └──┬──┘                       │                       │    bytecode    │   │
		│                          │                       └────────┬───────┘   │
		│                          │                                │           │
		│                          │                                │           │
	   ┌────┴─────┐                ┌───┴────────┐               ┌───────┴──────┐    │
	┌──┤State Poll├──────────────► │Request poll│       ┌───────┤Pending query?│    │
	│  └────┬─────┘                │            │       │       └───────┬──────┘    │
	│       │                      │     .      │◄──────┘               │           │
	   ┌────┴─────────┐  response  │     .      │                       │           │
	▲  │Await Response│◄───────────┤     .      │                       └───────────┘
	│  └────┬─────────┘            └────────────┘
	│       │
	│ ┌─────┴──────────────────┐
	└─┤Update visual state     │
	  │to reflect current state│
	  └────────────────────────┘

(To inferface Rust and JS we used the very good package "Neon".)

Finally, let me talk briefly about the manual.

The most obvious thing about it is that it's on a corkboard (I stole it from my girlfriend). The second most obvious thing is that one of the pages has coffee spilled on it (I stole that coffee from lab mates that don't empty the coffee machine).

This was a really fun part of the project, because we wanted to make the guide not just a reference to the assembly language of the machine, but also something with a lot of personality, the same way PDP-11 manuals are super endearing.

(as Adam Saltsman would put it, we wanted the manual to be good trash)

Furthermore, there's this underlying narrative we gradually constructed that TAU-800B is a heavily used machine in a lab setting.

To achieve that professional/corporate look, André and I went with LaTeX. However, the printed pages looked way too clean, so we beat them around, scribbled on them, and even spilled coffee on them.

Basically, what you'd expect from a very handled work paper.

(incidentally, my prints of physics papers may not look too different.)

This was also a super fun opportunity to weave modern terminology into what is supposed to be an old reference manual. Not to mention the time travel references!

I'm particularly proud of mentions to "Carnot-Landauer-Novikov principle" in the Energetics section.

(Link to a PDF of the manual at the end.)

The presentation wrapped all of these elements by showing TAU-800B at work, running some assembly that can be checked out pinned on the corkboard. (and on the screen while running!)

As a last nod to the theme, what it's doing is displaying the current time, but backwards.

(it then takes the square root of the hours and minutes, just to show off the time travel speed ups. Big thanks to André for his 6-bit assembly calculation magic!)

(we stayed true to the emulation when displaying the time: you have to write the correct bytes to a reserved position in memory, in order to control a virtual 7-segment display 😃)

That's it!

We'd love for TAU-800B to be exhibited again, so if you have an art-showing space and are interested (or know someone who is/does), let me know! You can also send me your thoughts about it via email :)

Manual PDF