Turing Tumble Community

How can I explain the gap between this and an actual computer?

My wife is enjoying the puzzles, but does not understand how this translates into a computer. She quickly picked up the concept of Binary numbers but does not understand how this translates into, for example, a Decimal number displaying on a screen.

What would be a good way to explain/demonstrate this to her?


GREAT question. Maybe someone else could explain it better than me, but here’s how I’d go about it:

I think there are two concepts that need to be explained. First, how Turing Tumble relates to what’s inside a computer chip. And then second, how you get from that to a more complicated system that can draw numbers on a screen.

1. How is Turing Tumble like an electronic computer?
Computers contain lots and lots of switches. How can switches do anything smart? Well not all switches can. For example, the switch on my wall can’t do anything smart at all - it just turns on and off the light. It can’t do anything more complicated because it’s a switch that turns electricity on and off, but it’s flipped mechanically. In order for switches to do anything more complicated, they have to be able to flip each other on and off. That means the switch needs to be flipped on and off using the same type of energy that it turns on and off. So an electrical switch would need to be flipped by electrical energy, and a mechanical switch would need to be switched by mechanical energy.

Regular electronic computers have tiny electrical switches that are flipped by electricity. They’re called “transistors”. They’re connected to each other with tiny copper wires inside computer chips. You can see kind of what they look like in this video. Notice how there are layers of wires. The layers make it possible for wires to cross over each other without touching.

In Turing Tumble, the ramps are like wires. They make paths that the balls must follow. The crossovers are like wires that cross over one another without touching. The switches are the bits and gear bits. They control something mechanical (whether a ball exits to the left or the right) and they are also flipped mechanically (when a ball lands on them).

Turing Tumble lets you see how switches can do logic and smart things, just like in an electronic computer.

2. How do you get from the little circuits you build in Turing Tumble to a more complicated computer that can display numbers on a screen?
Turing Tumble gives you the basic tools to build a more complex system, but it would take a much bigger board to be able to do everything a full computer processor does. You could start to imagine how it would look, though.

First of all, it would have memory. The memory would be a bank of bits where information can be stored and retrieved. That memory would be split into two types: program memory, where instructions are stored, and data memory, where numbers and other random bits of information are stored.

The processor would also have a small number of registers - maybe 8. Whereas memory is for storing information, registers are like the workspace of a processor. The processor copies information into the registers from memory, does something to that information, and then copies it back into memory when it’s done. It copies the information back to memory because it can’t hold the information there forever since there are only 8 registers.

So when it’s running, the processor would copy instruction codes one by one out of program memory, into the processor’s workspace, and do what they say to do. For example, the following four instructions would add two numbers together and store the sum in data memory:
Instruction Code #1: 23, 256, 1
In this case, ‘23’ is a code that says to copy something out of memory. ‘256’ is the starting memory bit to copy data from, and ‘1’ says to copy it to register 1.
Instruction Code #2: 23, 264, 2
The second instruction code says to copy the data starting at position 264 in the memory bits into register 2.
Instruction Code #3: 12, 1, 2, 3
In this case, ‘12’ is the code to add two numbers together. The processor adds the numbers stored in registers 1 and 2 and stores the sum in register 3.
Instruction Code #4: 24, 3, 272
In this case, ‘24’ is the code to copy something back into memory. The instruction says to copy whatever is in register 3 into memory starting at memory bit 272.

Hopefully that gives a feel for how the processor works. Now for displaying a number on a screen. A black and white monitor is also just a bank of switches - on or off, white or black. The switches are arranged in a grid on the screen, each switch controlling a pixel on the screen. When you want to turn a pixel on or off, you turn the switch on or off.

If you wanted to display a number on the screen, you’d have to first grab the number you want to display out of data memory. Somewhere in data memory, you’d also need to have pictures of each number stored, sort of like this:

That would be the number one.

To display the number ‘1’, your program would have to copy those bits to the bits on the screen. To show numbers other than ‘1’, your program (that is, the series of instructions in program memory), would need to check the number you want to display and copy over the right image. Is it a 1 (00000001)? Copy the ‘1’ image bits to the screen. Is it a 2 (00000010)? Copy the ‘2’ image bits to the screen. Is it a 3 (00000011)? Copy the ‘3’ image bits to the screen. And so on…

Does that help? If something isn’t clear or doesn’t make sense, say the word and I’ll try to improve this explanation.


When I’ve been explaining Turing Tumble to folks, I say it’s a puzzle game about digital logic, not a puzzle game about computing. If you feel like buying some electronics for play, a breadboard, a battery holder, and some jumper wires and ICs could help illustrate how Turing Tumble creations can be made with J/K Flip Flops, NAND and NOR gates, etc.

While it’s easy to see how a bunch of bits can hold an unsigned integer, it’s not as intuitive how you can use bits to represent signed integers or any sort of floating point numbers.

Signed integers use something called “two’s complement” to represent negative numbers. If the most significant bit is 0 the number is positive. If the most significant bit is 1 the number is negative, and you can flip the sign back to positive (or just read the value) by inverting all of the bits and then adding 1. Beyond that you can do math on signed numbers using the same circuits you use for unsigned, with the understanding that your “number line” now wraps around from 3 to -4 instead of 7 to 0, or from 7 to -8 instead of 15 to 0, etc.

Floating point numbers generally have some value bits and some metadata. In an unsigned integer all of the bits are value bits AND they have a standard numerical value for each bit: the least significant bit is always the 1s place, then the 2s place, then the 4s place, etc. A floating point number’s value bits can have different numerical values depending on the metadata: a single bit could be a 1s bit, or a 16384s bit, or – and here’s where the decimals come from – a fractional power of two value bit. There can be a 1/2 bit, a 1/4 bit, a 1/256 bit, etc.

The metadata will then include a sign bit, some bits of exponent (which shifts the numerical values of all of the value bits by powers of 2), and maybe some bits for special-use values (infinity, Not-a-Number, etc.)

(It seems I focused on the “decimal number” and Paul focused on “on the screen.” :slight_smile: Hopefully both perspectives are interesting and useful.)


What’s amazing is how well Turing Tumble shows off some of the concepts underlying a computer on such a small board.

In Paul’s answer (part 1) he references transistors. I’ve got no idea how many “transistors” can fit on a TT board, but the board’s only got 49 spots for components. Very small. By contrast the MOS 6502 chip that was used in many different computers back in the 70s and 80s (Commodore 64, Apple, NES, etc) had 3510 transistors. The Pentium chip from 1993 had 3.1 million. And computers don’t just have CPUs in them. They have RAM, video chips, sound chips, the chips in a hard drive that make it work, etc. They’re all loaded with their own transistors.

I mention this because it’s necessary to have a sense of scale here. You not only would have to build up TT boards for the CPU but all those other chips. You can get a sense of how many transistors the different elements have in them from https://en.wikipedia.org/wiki/Transistor_count – note that page has a neat chart showing how many transistors are required to build logic circuits.

I look at each puzzle as a program with defined constraints in terms of inputs and outcomes, but instead of writing a program in a computer language, I’m writing a program using the TT components. Along the way I have to form a mental image of what is going to be happening at each step and how it will affect the overall outcome. I am doing debugging when my solution doesn’t work as expected. The “programs” have state, they have inputs and outputs, they have loops, they perform algorithms and deal with basic branching.

Perhaps being a software developer biases my thinking here, but I think TT works best when not trying to compare it to computer hardware, but rather to software.

Or maybe that’s too much hand-waving? In that case, I’d look at expanding with other “toys” to bridge the gap a bit between what TT is and what a computer is – things like the Elenco 300-in-One Electronic Project Lab, which has actual transistors and integrated circuits. Then I’d consider something like Arduino as a next step.