Building a Computer 1010: Counting and Human versus Machine Error

I decided that we should use the prototype toggle that we built to actually do a computation. I realized that with some manual interaction we could do a marble count. Here is how it works:

Start with a pile of marbles and feed them all through the machine. Collect the marbles that come out of the two toggle outputs in two bowls (which I have labeled bowl A and bowl B. Once all of the marbles have been fed through, the machine will be in one of its two states: either the rocker will be to the left with no marble in the catch, or the rocker will be to the right with a marble in the catch. If you watch the machine operate you realize that when marbles are output they always come in twos. That is every time a marble goes into bowl A one also goes into bowl B and vice versa. So you can see that there will be a marble in the catch if and only if the number of marbles fed through the machine is odd. Furthermore, a binary number ends in a one if and only if it is odd. In other words, once all of the marbles have been fed through the machine you can read the right-most (or least-significant) bit off from the machine: a one if there is a marble in the catch, and a zero if there isn’t.

Once all of the marbles have been fed through and the bit recorded, you should reset the machine (move the toggle to the left, releasing the marble that’s caught if there is one). Now take out the contents of bowl A; this becomes your new pile.

Repeat the process, feeding all of your new pile through the machine, record the next bit (I’ll leave it to you to convince yourself that this really does tell you the next bit) and repeat the whole process until all of the marbles are in bowl B. At this time you should have the complete binary representation of your total number of marbles.

We carried this program out for our set of marbles four times…and we got four different answers….OK, I never claimed that our prototype machine works perfectly. Actually there were two things that went wrong. Sometimes two marbles would sneak through the same side of the machine before the toggle could flip to the other side. We called this a machine error. Sometimes we would do silly things like fail to empty bowl A before feeding its contents through the machine. Thus, some of the contents of bowl A from round n would get mixed with the contents of bowl A from round n+1. This (pretty clearly) causes problems. The results we got for our number of marbles were 96, 118, 119, and 136. Then we counted them by hand and got 118. One other thing I should mention is that we watched the machine as we fed the marbles through, and sometimes there were machine errors that we noticed and corrected in real time. In any case I think that 118 is the correct number.

This experiment has got me thinking a bit about operator error versus machine error. Often one hears operator errors called “human errors”, but it occurs to me that even the machine errors are due to humans. That is, the machine errors that occurred in our little exercise were due (almost certainly) to our poor craftsmanship and possibly due to bad engineering. So machine versus operator errors really come down, not to machines versus humans, but to the people who designed and built the machines on one hand and those who are operating them on the other.

About these ads
This entry was posted in computers. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s