Yeah, I know, clearly I’ve had threads on the mind a little too much lately. I’ve been working on a major refactor of the engine at work and thread synchronization problems are tricky.

Usually when I have dreams like this I wake up in the morning and have a good laugh wondering what the heck I was thinking. This time, however, I think there may be something to it. Now, I’m not suggesting a design built literally on the model exactly as it is in the dream but I think there are elements that could be useful.

The part that is intriguing about the turret defense thread model is that you can guarantee completion (all units hit) without guaranteeing really very much at all about either the turrets or the units. The units are not synchronized with each other; in fact, in many tower games faster units can overtake slower ones. A unit does not guarantee a minimum speed–it may even be allowed to stop entirely on occasion–although it does guarantee a maximum speed. The turrets are not synchronized with each other, nor do they communicate any information to each. A turret does not guarantee a specific number of units hit, only that it will hit units at a specific rate. A turret also does not guarantee what order it will fire at units in. A unit likewise guarantees nothing about when or by whom it will be hit except that it can be hit when it is within a valid range.

Yet, with a sufficient number of correctly placed turrets all the units will be hit with none escaping. More importantly, most of the time you can have far fewer turrets than units and still complete successfully. The number of turrets required is a simple function of the maximum speed of the turret, the maximum speed of the unit, and the number of times the turret must hit the unit for completion. Placement is trickier, but with a thread model you could surely replicate that with signals.

Fascinating, isn’t it?

I’m not sure yet where to go with all this, but it seems like there’s a useful idea to be gleaned. It’s not that different that a traditional worker pool, but the lack of communication seems important. I’m sure there’s something useful that can be done with this.

1. For anyone who cares, the specific game seems to be Crystal Defenders, but with some elements of Bloons Tower Defense 3.

More tips? Ideas you would recommend? Post a comment!

Gyosan asked Isan, “If a million objects come to you, what should you do?” Isan answered, “A green object is not yellow. A long object is not short. Each object manages its own fate. Why should I interfere with them?” Gyosan bowed in homage.

It’s good advice for programming multi-core, too.

Download the plugin. (Requires Windows XP, AC3D 6.2 or above.)

This looks like an interesting project, providing a growing body of useful research for seasoned developers, as well as game design contests and curriculum tools for students and educators.

http://valuesatplay.org/

Technically speaking, ambient occlusion is a global illumination technique. However, in common usage of the term it is often referred to as a cheap alternative to global illumination. To clear up any confusion, what most renderers refer to as “global illumination” is actually an amalgamation of several techniques such as radiosity, metropolis light transport, image-based lighting or photon mapping. The actual techniques used differ slightly from renderer to renderer. Some renderers include an ambient occlusion term as part of their global illumination calculation; others do not.

Like most global illumination techniques, ambient occlusion is dependent on the other geometry in the scene. Ambient occlusion on its own generates less realistic lighting than “full” global illumination. However, ambient occlusion is much faster and less complex to calculate than other methods which is why it is still popular among game developers and in production animation.

(Left) Without Ambient Occlusion. (Right) With Ambient Occlusion
Click for larger image.

How Does Ambient Occlusion Work?

To understand how ambient occlusion works, it’s helpful to break down the terms.

“Ambient” refers to the indirect light in the scene. Ambient light is light that doesn’t come from an identifiable light source. It is light that is accumulated from stray photons bouncing around the room. Photographers sometimes also call this kind of light source “available light” or “existing light”.

“Occlusion” is the act of one object blocking another object. For example, if you are taking a picture and at the last moment a truck drives in front of you blocking the shot, the truck is “occluding” your view of your subject. Occlusion is important to computer graphics for many things besides just shadows. For example, many renderers can optimize the scene and render faster by culling objects that are occluded, or hidden, by other objects.

Ambient occlusion is a measurement of how much ambient light is blocked by nearby things. If an object or surface is occluded, less light can reach it, which means the surface will be in shadow. Creases, corners, hollows and the undersides of things tend to have a lot of ambient occlusion.

For Artists: Rendering with Ambient Occlusion

Most modern renderers support either some form of global illumination or ambient occlusion; many support both alone or in combination.

Ambient occlusion improves your render by making small details more visible and improving depth perception. A lot of the way humans perceive depth has to do with the size, darkness, and placement of shadows. Using ambient occlusion to add shading to your scene will help the viewer comprehend the placement of objects better.

Ambient occlusion in Poser 6

While each renderer is different, often the basic concepts are pretty similar between many of them. As an example, here’s how you can add ambient occlusion to your render in Poser:

- Click to the Materials tab
- Use the eye dropper to select the material you want to edit
- In the Material Properties node editor, click the Set Up Ambient Occlusion Button. This will add an ambient occlusion node to you material shader.

Poser 6 gives you four properties you can adjust on the ambient occlusion node:

Samples – The number of ray samples that will be cast. The more rays, the finer the lighting, but the longer the render. Keep this number as low as you can unless the lighting looks splotchy, in which case, turn it up.

MaxDist – The maximum distance the ray will test. Larger values generally result in more shadows.

RayBias – The smallest distance the ray will test for objects. If you get black blotches on your figure, very slightly increase your ray bias. If you increase it too much, you will start missing shadows, so don’t turn it up more than you need to.

Strength – The blend weight of the effect.

For Programmers: Implementing Ambient Occlusion

As far as bang for the buck, ambient occlusion is one of the fastest ways to improve the quality of your game’s lighting without a tremendous amount of pain. There are many, many algorithms out there for calculating ambient occlusion and each has advantages and disadvantages depending on your engine features. That said, there are two methods in particular I’d like to point out.

Monte Carlo Ray Casting Method
I’m not sure if this is the oldest method for calculating ambient occlusion or not, but it was certainly the first method learned. Assuming you already have some sort of ray-triangle collision code, this method is very easy to understand and implement.

For each point you want to calculate lighting for, shoot out a number of random rays. (In truth, you don’t really want completely random rays… small random offsets from your surface normal seem to work best.) If the ray hits something, increase the shadow value proportional to the distance along the ray where the collision occurred.

With enough samples per point, this method can produce very good results. The downside is that this method can be very slow. Many games utilizing this method don’t calculate the ambient occlusion in real-time… the ambient occlusion is calculated when the level is loaded or off-line when the level is built, and the results are stored in a texture map.

[Incidentally... yes... looking at Poser's settings, I'm guessing this or something very similar is the method they are using!]

Screen Space Method
Screen space ambient occlusion has been generating a lot of buzz lately. Screen space rendering methods in general are always desirable to real-time programmers because they run in constant time and constant memory, and aren’t inhibited by scene complexity. A good starting point for learning about screen space ambient occlusion is Martin Mittring of Crytek’s Siggraph 2007 presentation.

Basically, the notion is that by sampling surrounding points in the depth buffer you can estimate shadowed areas. Think of it (sort of) like running an edge-detection routine on the z-buffer. The method can produce some artifacts, but there are number of ways to combat them… and the benefit of course is that this method is fast even on complex scenes.

Again, there are many methods out there and numerous variations, but hopefully this is enough to get you pointed in the right direction!

Questions? Ideas? Links to your favorite method? Post a comment!

In the latest move, Sony Computer Entertainment, the unit responsible for the PlayStation, reduced the price of the SDK, which SCE calls the Reference Tool, to $10,250 in North America, $8,600 in Japan, and $11,250 in Europe. In addition, SCE said it would enhance the development environment by integrating programming tools from SN Systems. SN’s core tool is called ProDG.

Read the rest of the article here.

Single-Head Addition

Now that we have our Turing machine, it’s time to write some programs for it! Last time, we wrote a simple incrementer to learn how the machine works. This time, we’ll write something (slightly) more complicated. Let’s try some basic arithmetic, starting with addition.

First, you will need to set up your Turing machine. Since we’re still working with only one tape, we’ll need to put both numbers we want to add on the same tape. Separate each number with a blank. For example, if I wanted to add the numbers 3 + 5, my tape would read 1-1-1-0-1-1-1-1-1. As before, place the head at the start of the first number.

Let’s assume we want to overwrite the tape with the answer. So, when we start the program, the tape will contain the two numbers we want to add. When we finish running the program, the tape will contain the sum of the two numbers.

There are lots of ways we could go about adding the two numbers, but there’s one very obvious way to do it. Squish the two numbers together! Sure, it sounds cheesy, but it’s a pretty efficient way to accomplish our task.

Here’s the outline:

- Move the head past the first number to the blank.
- Move the head past the blank.
- Move the head to the last digit of the second number.
- Remove the one and change it to a blank.
- Move the head to the blank between the numbers.
- Write a one.
- Reset the head to the start.

Each of these steps can be accomplished with simple loops to move past the written values, similar to the incrementer. However, we’ll need to add a little more logic to our loops, to handle the case when either operand is a zero.

Watch the adder program in action

Start by moving the head past the first number. This loop is similar to the one in the incrementer, however, we’ll need to “flip the loop” by moving the head before we check for the value. That way, we’ll be sure our head ends up where we mean it to be, regardless of what the first number is.

#1: Move the head right one space. Go to the next instruction.

#2: If the current value is 1, go to instruction #1. Otherwise, go to instruction number #3.

Next, we must move past the blank:

#3: Move the head right one space. Go to the next instruction.

Once past the blank, we need to find our way to the end of the second number. Use a loop to move the head past the second number, then retreat one space so that the head is on the last digit:

#4: If the current value is 1, go to instruction #5. Otherwise, go to instruction #6.

#5: Move the head right one space. Go to instruction #4.

#6: Move the head left one space. Go to the next instruction.

Now, we need to replace the last digit with a blank… but not so fast! What if the second number is a zero? We need to handle this special case. If the second number is a zero, we’ll just skip to the end and reset the head. Otherwise, we’ll merge the two numbers.

#7: If the current value is a 1, go to instruction #8. Otherwise, go to instruction #13.

#8: Write a blank. Go to the next instruction.

#9: Move the head left one space. Go to the next instruction.

Now, it is time to start moving the head back in the opposite direction. Seek to the left until we find the blank separating the values:

#10: If the current value is a 1, go to instruction #11. Otherwise, go to instruction #12.

#11: Move the head left one space. Go to instruction #10.

To combine the numbers together, replace the blank with a 1. This doesn’t change the value, because we already removed a 1 from the end of the second number:

#12: Write a 1. Go to the next instruction.

#13: Move the head left one space. Go to the next instruction.

We’ve calculated the sum! The tape should now read the sum of the two numbers. But, for good practice, we aren’t quite done… to do this right, we want to make sure we restore the head so that it points at the start of the value written to the tape. We can do this exactly the same way as we did in the incrementer, by moving until we find a blank, then stepping to the right.

#14: If the current value is a 1, go to instruction #15. Otherwise, go to instruction #16.

#15: Move the head to the left one space. Go to instruction #14.

#16: Move the head right one space. End program.

And we’re done. Try it out and see how it works!
Here’s the complete program listing:

-Adder-
#1: Move the head right one space. Go to the next instruction.
#2: If the current value is 1, go to instruction #1. Otherwise, go to instruction number #3.
#3: Move the head right one space. Go to the next instruction.
#4: If the current value is 1, go to instruction #5. Otherwise, go to instruction #6.
#5: Move the head right one space. Go to instruction #4.
#6: Move the head left one space. Go to the next instruction.
#7: If the current value is a 1, go to instruction #8. Otherwise, go to instruction #13.
#8: Write a blank. Go to the next instruction.
#9: Move the head left one space. Go to the next instruction.
#10: If the current value is a 1, go to instruction #11. Otherwise, go to instruction #12.
#11: Move the head left one space. Go to instruction #10.
#12: Write a 1. Go to the next instruction.
#13: Move the head left one space. Go to the next instruction.
#14: If the current value is a 1, go to instruction #15. Otherwise, go to instruction #16.
#15: Move the head to the left one space. Go to instruction #14.
#16: Move the head right one space. End program.

Multi-Head Addition

A multiple-head Turing machine doesn’t have any computational advantage over a single-head Turing machine–anything you can compute on one, you can compute on the other–but multi-head Turing machines can sometimes make your programs easier to conceptualize, especially for complicated algorithms.

From here on out, we’ll use a multi-head machine. To show how a multi-head\multi-tape machine works in comparison to a single-head machine, we’ll implement addition again, this time using three heads and three tapes instead of one.

To setup your Turing machine for a multi-headed operation, we need to create one tape for each head. Lay out your tape index cards in three rows. Place one head above each tape row.

The first and second tapes will hold our two “addends”, or numbers we want to add together. Place the first number you want to add in the first tape. Place the second number you want to add in the second tape. The third tape will hold the result. Set the third tape to blank.

The outline for a multi-head addition operation is much easier to follow:

- Copy the value from the first tape to the third tape
- Append the value from the second tape to the third tape
- Reset all three heads

Not only is this program more intuitive to read, it also eliminates the need to check for zero values.

Example of the multi-head adder

Let’s walk through the code:

#1: If the current value of head #1 is 1, then go to instruction #2. Otherwise, go to instruction #5.

#2: With head #3, write a 1.

#3: Move head #3 to the right one space.

#4: Move head #1 to the right one space. Go to instruction #1.

What this segment does is copy the value of the first tape to the third tape. Every time head #1 reads a 1, head #3 writes a 1. This segment keeps looping until tape #1 runs out of 1′s.

The next section is essentially the same, except that it copies data from tape #2 to tape #3:

#5: If the current value of head #2 is 1, then go to instruction #6. Otherwise, go to instruction #9.

#6: With head #3, write a 1.

#7: Move head #3 to the right one space.

#8: Move head number #2 to the right one space. Go to instruction #5.

Tape #3 now holds our result! All that’s left is to reset the heads to start. Here is the complete listing:

-Multi-head Adder-
#1: If the current value of head #1 is 1, then go to instruction #2. Otherwise, go to instruction #5.
#2: With head #3, write a 1.
#3: Move head #3 to the right one space.
#4: Move head #1 to the right one space. Go to instruction #1.
#5: If the current value of head #2 is 1, then go to instruction #6. Otherwise, go to instruction #9.
#6: With head #3, write a 1.
#7: Move head #3 to the right one space.
#8: Move head number #2 to the right one space. Go to instruction #5.
#9: Move head #1 to the left one space.
#10: If the current value of head #1 is 1, go to instruction #11. Otherwise, go to instruction #12.
#11: Move head #1 to the left one space. Go to instruction #10.
#12: Move head #1 to the right one space.
#13: Move head #2 to the left one space.
#14: If the current value of head #2 is 1, go to instruction #15. Otherwise, go to instruction #16.
#15: Move head #2 to the left one space. Go to instruction #14.
#16: Move head #2 to the right one space.
#17: Move head #3 to the left one space.
#18: If the current value of head #3 is one, go to instruction #17. Otherwise, go to instruction #19.
#19: Move head #3 to the right one space. End program.

Subtraction

Hopefully, by now you’re starting to get a grasp on how to write simple programs for your Turing machine.

I’m not going to post a complete program listing for subtraction, as it’s pretty much the same as addition (if you can’t figure it out, ask me and I’ll help you out). If you build a three-tape setup, where tapes #1 and #2 store the numbers you want to subtract and tape #3 stores the result, then you can implement subtraction by copying the value from tape #1 to tape #3, then decrementing tape #3 by the value of tape #2. Very straight-forward.

There’s only one gotcha you need to look out for in subtraction: what happens if the second number is larger than the first number? You could, of course, choose to ignore this case. A better thing to do would be to finally bust out those paperclips and use the state register. If you decrement a value from tape #3, but the current value of tape #3 is already zero, change the state by adding a paperclip to indicate that the result you are writing on tape #3 is a negative value. If you don’t want to use a state register, you can accomplish the same thing by using the first cell on tape #3 to indicate whether the value is positive or negative. If the value is blank, the result is positive. If the value is 1, the result is negative. That is more-or-less what modern computers do. In any case, there are lots of good ways to handle the scenario–the important thing is that you check for it.

Questions? Ideas? More programs you’d like to see? Post a comment!

This is a fun afternoon project for all ages, and a great way to introduce both kids and adults to the fundamentals of computer programming.

Supplies

You will need:

- A magic marker
- A deck of 3×5 index cards
- Paperclips (optional)

One deck of index cards will allow you to build the machine and write several programs for it. If you want to write more programs, you will need more index cards. If you don’t have index cards, you can use paper instead.

Understanding Numeral Systems

Before you can build and use a Turing machine, you need to know a little bit about number systems. For example, most people know that modern computers are “binary” or that the numbers we ordinarily use to count with are “decimal”, but what does that mean exactly?

The words “binary” and “decimal” refer to the base of the number; the base is how many digits you must count before you roll over to the next digit. Decimal means base ten. Think decathlon or decimeter to remember that decimal means 10. Base ten means you must count ten digits–zero through nine–before you start re-using them and move to the next column. For example, if you start at zero and count all the way up to nine, when you reach nine you run out of digits, so the next number becomes one-zero. (Ten is just a fancy word for one-zero!) Likewise, when you get to 99 you run out of digits again, so the next number becomes one-zero-zero. i.e. 100

Binary means base two. Think of the words bicycle or biplane to remember that binary means two. To count in binary, you count two digits–zero through one–before you start re-using them and move to the next column. To count in binary, first you count zero, then one, then you’ve run out of digits so the next number becomes one-zero. Just like in decimal, every time you run out of digits you roll over to the next column.

Modern computers use binary, but the Turing machine we are about to build uses an even simpler numeral system known as “unary”! A unary numeral system is a base one numeral system. Think of the words uno or unicycle to remember that unary means one. In a base-one system, you start at one, and then immediately move to the next column with one-one, then one-one-one, then one-one-one-one, and so on. This may seem strange, but you use this system all the time even if you do not realize it! For example, tally marks are a popular everyday usage of a unary numeral system–one line equals one number. Counting on your fingers, or using candies or pennies to track points in a playground game are other good examples of everyday unary counting.

[Side note: For those who may be concerned, grouping your tally marks by five isn't the same thing as a new digit... it's just like using a comma between thousands-places in decimal. It doesn't change the number; grouping the digits simply makes it easier to read.]

How a Turing Machine Works

A Turing machine consists of an infinitely long tape, upon which “symbols” (i.e. numbers) can be written by an attached read\write recording head. The head has both a finite state and a finite set of instructions, telling the head what to do when it encounters a symbol on the tape. At each instruction, the machine may modify the symbol on the active location of the tape, change the state of the head, or move the head left or right on the tape.

The finite set of instructions is the key to it all. The idea in a nutshell is that if can you write down the exact procedure for doing something, you can hand that set of instructions to someone else and they’ll be able to do exactly what you did and come up with the same result. Note, that your list of instructions must be finite. “Finite” means “limited”. This is important, because it means that you can’t just go on writing new instructions forever. It means that once you’ve written down your steps, that’s it, you’re done. You’ve got to write down all the instructions about what could happen and how to handle it up front, before the other person tries to follow the instructions. You can’t add more later. A set of instructions like this is called an algorithm.

Think of an algorithm like a recipe. If you follow the exact steps, you’ll get the right answer to the computation; in the same way that if you follow the exact recipe for baking a chocolate cake, you’ll get a chocolate cake. Sometimes, as part of the recipe, you might be asked to make a decision and follow a different procedure based on the current state. For example, in a recipe for chocolate cake, you might be asked to stick a toothpick in the cake and see if it comes out clean. If the toothpick has sticky cake on it when you pull it out, the recipe will tell you to put the cake back in the oven for a bit. If the toothpick is clean, however, the cake is done and the recipe will ask you to take the cake out of the oven. In a computer program, this is called a “branch instruction”. It means, “read the current state, and do either A or B depending on what the state is”. Branch instructions let you make very powerful algorithms.

A Universal Turing machine, or UTM, is a Turing machine that is able to simulate another Turing machine. This is a very powerful concept, as it relates to the modern idea of stored programs. Basically, what Turing said is that if you could come up with a set of instructions to solve a problem, instead of just coding them permanently into a Turing machine, you could write those instructions into a table or tape in a way such that another Turing machine could play them back. This “universal machine” could then be used to solve many different kinds of computations depending on the program written in its instruction table. Neat, eh?

How to Make a Turing Machine

Take about half of your index cards, maybe a little more if you want to compute larger numbers. Turn the index cards so they are taller than they are wide; this will make your Turing machine a bit easier to fit on your desk later. Write a “1″ on the front of each index card. Write a “0″ on the back of each index card. This stack of index cards will form your “tape”.

Now, take three index cards and draw an arrow pointing down on them. These will be your read\write “heads”. In the corner, label each head 1, 2, and 3. In theory, any computation that can be solved on a machine with multiple heads can also be solved on a machine with a single head, but in practice some things are a lot easier to program if you have multiple heads.

The rest of your index cards we’ll use for writing programs. This is your table of commands or “instruction stack”.
Advanced Stuff: What about the “state register”? Earlier, we mentioned that a Turing machine consists of a tape, a head, a state, and a set of instructions. We have the tape, the head and the instructions… but what about state? Well, for simple programs you don’t really need it–the “instruction pointer” (aka. what instruction you are on) and multiple heads gives you all the state you need so I’ve omitted a separate register. But, if you really want one, you can use paperclips. Simply attach or remove paperclips from the heads to track your state; the number of paperclips denotes what state you are in. Again, you don’t really need it unless you are going to get fancy, so I won’t be using it in the examples.

Set Up

To set up your Turing machine, first you must lay out your “tape”. Place the tape index cards face-down in a long row, so that they all read zero.

Next, place the first “head” index card above the tape. Position the head at least three index cards over from left hand side of the tape. This is your starting position. You don’t want your starting position to be on the first index card, because you need to be able to move the head to the left of start for some programs.

My Turing machine displaying the number ’2′.

You can now enter an “initial value” into your machine. Your initial value is whatever number you want to perform an operation on. Starting at the head position, flip over index cards so they read “1″ until you reach whatever value you want to start with. Remember, a Turing machine uses a unary number system. This means that each 1 written on the tape increases the value of the number by one. For example, if you wanted to perform an operation on the number four, you would flip over four index cards. Your tape would read 1-1-1-1.

How to Program the Computer

To program your Turing machine, you must write a set of instructions on a stack of numbered index cards. The rules for programming a Turing machine are simple. One index card = one instruction. Be sure to number your index cards in case you drop your program on the floor so they don’t get mixed up.

On each instruction you may do any of the following things:

- Read the current value of the tape. The current value is whatever number is written on the tape at the position that the arrow on the head is pointing to.

- Write a new value to the tape. You can flip over the index card that the head is pointing to, to change its value.

- Move the head a specified number of spaces to the left or to the right. For example, you could say “move the head three spaces to the right”.**

- Specify the next instruction to execute. You may “branch” instructions, and specify a different instruction to execute based on the current value of the tape. For example, you can say “If the value of the tape is 1, go to instruction #10. Otherwise, go to instruction #12.”. If you don’t specify an instruction, it is assumed that you mean to run the next instruction in the sequence. If the current instruction can’t be executed, the machine halts.

Additional programming tips:

- Always finish your programs in a “known state”. That means, return your head to the start position after you finish your calculation, don’t just leave it dangling out there. You should always be able to run the next program immediately after you finish your last without resetting anything.

- Geeze-o-pete, don’t do the “if the current instruction can’t be executed, the machine halts” thing! That’s called “crashing the computer”. If you mean your program to finish, write “end program” on the instruction index card instead.

Yes, folks, even a computer based on a deck of index cards can crash!

Your First Program: The Incrementer

A great program to start with is an incrementer. It’s a very simple operation, and a good example of how the machine works. It’s also a very useful operation, as modern computers use incrementers all the time for many different things.

An incrementer takes the current value, and adds one to it.

So, what is the algorithm for an incrementer? Well, remember that our Turing machine uses a unary counting system. That means, if we want to increase the value of a number by one, all we need to do is write another 1 to the tape.

I always like to break programs down into their steps before I write them, so here’s the general outline for the program:

- From the starting position, move the head past the end of whatever value is written on the tape.
- Write a one.
- Move the head back to the starting position, so we finish in a known state.

Ok! Now all we need to do is break it down into the individual instructions. So, first things first, let’s find the end of the value on the tape. Here’s how to do this, using the rules we outlined earlier:

#1: If the current value is 1, go to instruction #2. Otherwise go to instruction #3.

#2: Move the head to the right one space. Go to instruction #1.

Excellent. These two instructions will cause the program to loop until the head moves to the first blank space. Once we’ve reached the end of the value we want to increment, we have to add a one.

#3: Write a 1. Go to the next instruction.

Ok! We’ve done it, we’ve incremented the number. That wasn’t bad at all, was it? Some programmers would just end the program here, since it’s completed the task. However, a good programmer will leave the system in a known state and ready to run the next program. We’re good programmers, so we’re going to move the head back to the start.

#4: If the current value is a 1, go to instruction #5. Otherwise, go to instruction #6.

#5: Move the head to the left one space. Go to instruction #4.

#6: Move the head right one space. End program.

This code segment is another loop, similar to our first two instructions. It causes the head to keep moving left until it reaches a blank. When the head reaches a blank, we know we must be immediately before the start. So, we move the head back one step to the right leaving the head pointing at the start position and ready to run the next program. That’s all there is to it!
In summary, here’s the complete program listing:

-Incrementer-
#1: If the current value is 1, go to instruction #2. Otherwise go to instruction #3.
#2: Move the head to the right one space. Go to instruction #1.
#3: Write a 1. Go to the next instruction.
#4: If the current value is a 1, go to instruction #5. Otherwise, go to instruction #6.
#5: Move the head to the left one space. Go to instruction #4.
#6: Move the head right one space. End program.

To “run” the program, simply do exactly what it says on the index cards. If the card says move the head to the right, for example, move the index card representing the head one space to the right, so that it’s pointing at the next index card in the tape. Be sure to follow along exactly.

You can run this program again and again, and increment the number as many times as you like… or, at least until you run out of tape! A theoretical Turing machine has an infinite tape, so it doesn’t have problems with limited storage. Of course, that’s impossible to build in real life. Our tape is limited by the number of index cards we have, but I’m sure you can already see it doesn’t take a very long tape for the machine to be useful. If you want to operate on larger numbers, add more index cards. Be warned though: just because a Turing machine is a very powerful computer, that doesn’t mean it’s a very fast one!

Next time, we’ll implement some basic arithmetic, and learn how to use our Turing machine to add two numbers together.