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.” 
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.
I love these explanations. Each one give me a tidbit more understanding of the larger picture. I would love to hear a woman’s voice in this process. Men seem to focus on skills, skills, skills - which are helpful but not the end. I see that with my male students in middle school and on topics that I am informed on find it limited in terms of SEL/implications with regard to the impact it has on others. Women tend to also look other factors, inputs, reasoning perspectives. I would love to hear their voices. Ladies?
I think it doesn’t help to answer the original question by explaining electronics, computer architecture, boolean gates, or instruction codes. Nor do I think any of them are necessary to formulate an intuition-satisfying answer. IMO the biggest (and only) hurdle is needing to develop an intuition about what Turing Machines are capable of, given a background with only TT.
First, do away with the physical constraints of TT without breaking its model. We’ll need an arbitrarily large (but finite) TT board with an arbitrarily plentiful (but finite) supply of pieces & marbles. Let’s also allow the mechanics of TT to run arbitrarily quickly.
Next, imagine that any bits on the board can be functionally connected to human-interfacing hardware. An input example would be a keyboard where whether I were holding a key down or not corresponds to a bit pointing right or left. An output example would be a bit pointing left or right corresponding to a pixel on a display showing either black or white.
From there, all that remains is to integrate the intuition about how a Turing Machine can “compute anything”, and it follows that this physically unconstrained TT board that powers a keyboard and screen is what we call a computer.
And just like there exists some board configuration that draws Tetris on that screen, pieces dropping or moving (i.e. being drawn differently the next “display frame”) depending on what keys I’m holding down, there are also board configuration equivalents for any software that exists or has yet to be written as well.
A typical workflow with a computer is:
1\ user inputs something
2\ the computer does something (invisible)
3\ it spits out an answer (visible)
These can of course take many forms
1\ user input: Type a number on a calculator or
Type text on your keyboard
2\ does something: adds two values together or
searches the internet
3\ output: Displays a number on the screen
Displays a hit list
This is what we are used to
TT concentrates on (2)
What is missing for a real-world connection are steps (1) and (3).
Below a probably very poor attempt to connect TT with the real world…
TT is obviously very limited in processing power. Which is OK, that’s not the aim of TT.
But it could be potentially used at least to demonstrate a very simple 1,2,3.
Going back to the definition
1\ user inputs something
manually set 3 bits to create a number (0 to 7)
2\ the computer does something (invisible)
convert the 3-bit number to a corresponding 8-bit Byte
3\ spit out an answer (visible)
Displays the 8-bit Byte on a 7-sergent display
Step 1\ manually set 3 bits to create a number (0 to 7)
Examples 000 = 0, 001 = 1, 010 = 2 etc.
Example shown below is 010 = 2
First row is the Bit 1, second row is bit 2 etc.
Note all bits in a given row must be pointing in the same direction.
This could be achieved by mechanically coupling using already available TT components.
Step 2\ Converts the 3-bit number to a corresponding 8-bit Byte
A single ball (think of as an electron) falling through the chain will get sorted according to the number dialed in by the user. eg. 010 will go to position 2.
Below is a 7-segement display labelled with the corresponding elements A-G (equivalent to 0-7)
To generate a number 2 we need the following Byte
A ON
B ON
C OFF
D ON
E ON
F OFF
G ON
This can be represented as a column of bits. In this case hard coded ie. They do not move.
A 9th bit could be added above the column to turn the column on, like a row of xmas lights. An electrical connection between the 9th bit and each of the individual bits is sketched below.
3\ Displays the 8-bit Byte on a 7-sergent display
Extending the electrical connection to all 8 positions the rudimentary computer is now complete. A ball dropped from the top will be routed according to user input. It will then land in its corresponding position and display the result on the 7-segment display.
Of course, this relies on a mechanical to electrical conversion at the last step. Something difficult on practice on a TT board but easy to imagine at least, which is whole point.
Also the input is somewhat archaic, having to physically turn bits to enter a value.
But pressing a keyboard I guess the above workflow in reverse. Here we click on a familiar number, it sends a series of hard coded bits (a byte) which is the number in binary format.