Chips With Everything – Learning from the Computation Game – [Work-in-Progress]

Introduction

One way or another computers are ubiquitous in 21st century life. Everything has a chip in it, every device has some programming interface, – every game (or even every motor car it seems) has a “cheat” code, and the “Internet of Things” (IoT) is soon upon us.

The pace of growth and change is mind-boggling, not just in devices and apps, but in the spread of languages architectures and possibilities in programming too. We all need to interact with computing technologies one way or another, but how much about that information and computing “supply chain” we need to understand varies enormously. One way or another everyone in education, needs to come out with at least an appreciation of the whole and knowing a meaningful place for themselves within it.

We cannot all simply be consumers and users.

The “Year of Code”, “Apps for All” and other initiatives have acknowledged that simply learning some programming and using a programming language must be part of that education, however obsolescent the particular code and language might turn out to be in terms of an immediate job or specific career. But the learning can and should be much more; after all education is more than career training.

Demystifying Computation.

It’s necessary and possible, as we will see in the later education proposal, to demystify computing itself.

And it is necessary for even more far-reaching reasons, beyond computing technology and applications. Computing is part of a much wider convergence across multiple disciplines. Computation is a fundamental evolutionary and functional process of nature underlying not only Computing, but also Biogenetics, Cognitive Science and even Physics itself.

Computation is a fundamental process of nature. For that reason alone everyone can and should have at least an appreciation.

Fortunately, however quickly computing devices and applications are evolving, some key aspects of computation remain simple, fundamental and (so far) timeless. These are worth appreciating in themselves, since once understood they demystify the evolving complexity of computer applications and the fundamental nature of computation in other disciplines.

What follows is a proposal for a teaching resource that lends itself to a very simple hands-on group computation exercise. An exercise that anyone progressing through higher education can experience, and indeed even 10/11 year-olds can find stimulating. [I did the exercise myself aged 13 in the classroom in 1969 and its value has stuck with me ever since.] Education professionals can decide and tailor where the exercise might fit existing curricula and classes, but it is a simple and attractive educational exercise.

The (developing) proposal is in three parts:

  • Its origins and a brief outline.
  • A more detailed (as yet incomplete) specification for the exercise and resources needed.
  • Additional considerations and follow-up exercises.

[Any educator who finds this interesting, please contact me with suggestions for how it should be developed as a teaching resource.]

The Registry Assembly Programming educational resource.

Origins and outline.

The basic simplicity of computation goes back to Turning, von-Neumann, and others. Turing has a place in topical public consciousness through his WWII “Code-Breaking” work first and foremost and for others through “The Turing Test” of artificial intelligence. Unless you happen to be in the business, for the most part these claims to public fame have come to overshadow his more fundamental conception of The Universal Turing Machine. But fundamental it remains.

One person who has done most to promote its fundamental value, beyond the computing business, is Daniel Dennett. He’s developed it in many forms with his own students and collaborators over his years in Cognitive Science at Tufts University, and his “Seven Secrets of Computer Power” has been published in various forms. Most recently as Chapter 24 of his Intuition Pumps and Other Tools for Thinking. And, as part of a series on “Convergence”, that chapter has also been published as a booklet by the Royal Institution and the Brain Mind Forum and Real Time Club associated with the British Computer Society. (The proposal here may involve these same organisations in collaboration with the Rationalist Association.)

Dan Dennett’s “Seven Secrets” work – with due acknowledgement to Turing – demystifies computing by showing that the fundamentals of computation are very simple and very few. So simple and few that Rule 7 is “there are no more rules”.

In leading his readers and students through those rules Dennett uses a “Registry Assembly Programming” (RAP) exercise to illustrate how these simple rules work. The beauty of the exercise is that, initially anyway, the “computer” can be a group of students playing or acting out the workings of a computer. The exercise couldn’t be simpler or more tangible for the students. As the exercise progresses to ever more complex computation, to illustrate the six rules, the physical exercise can be replaced by a visual simulation using the “Rodrego” application developed by Dennett’s students and colleagues over the years. Having done the earlier parts of the exercise by hand the students extrapolate the processes through using and observing the simulator. In fact the simulator makes little sense unless and until you have actually done it with your bare hands and brain. In Dennett’s own words “Life is short, and once you have internalized the basic processes in your imagination, you can now take advantage of a prosthetic device …” The RodRego simulator. Like watching the electrons whizzing around inside a computer at a scale and speed where you can appreciate what is really going on.

The RAP exercise in more detail.

The RAP exercise is the hands-on practical part of the Seven Secrets lesson. What follows describes the exercise itself. The learning outcomes, follow-up questions and additional exercises can be developed further.

Pre-requisite – A group of students on chairs and a bucket of bits / beans / chips. Paper hats or labels indicating the role each student is playing. [Pictures of physical arrangements will help.]

Let’s play at being a computer. The “game” is actually a human implementation of a Universal Turing Machine, but students don’t initially (or indeed ever) need to know this, unless that is part of their specific theoretical syllabus.

As an interactive exercise as few as 3 students can take part, but 8 to 10 works well. (In fact any one individual can do the exercise themselves on a desktop with a set of small boxes to act as registers and perform all the processing, reading and writing functions themselves. One can even do it as a paper or board-game exercise.) But it’s more fun to learn and, for most students presumably, more effective to work interactively with a group. As well as your own actions, you see and appreciate the actions of the others working together. The more the merrier for the younger participants.

1 to 3 students are the processors controlling, reading and writing, the programme instructions and the inputs / outputs. Tasks can be divided up variously, but 3 works well one the controller, ordering the others, one to perform the reading and the other the writing instructions, say.

Another 4 to 6 students act as the registers. Sitting in a horseshoe or two lines arrangement facing each other, with enough room for the processors to get up off  their chairs at one end and walk between the others. That way the communication itself is made visible to all.

Each step is very simple, that’s the very point in fact. Controller asks writer to take a chip from the stock or register Y and give it to register X. Controller then sends reader to ask register Z and report back how many beans they have.

And that’s it.

Controller of course has a set of instructions – a register assembly program (RAP) – and the instructions being performed are either loading up the program in the computer registers, putting input values into other registers, and performing the programmed instructions previously loaded into registers, and/or reading output values from the registers.

They real key is that the RAP really has only 3 possible instructions

  • Inc – Increment – ie add one bean to a register, and go to next step
  • Deb – Decrement-or-Branch – ie remove one bean from a register and go to next step, unless register is empty in which case go to another branch step.
  • End – Stop – ie there are no more steps to perform in this program, go find a human (teacher).

The beauty of the exercise is that from these 3 simple steps EVERY computation imaginable follows – rendering the most complex graphic simulation or running Amazon or Instagram. Yes, really.

OK show me. This is the start of the exercise in Seven Secrets – following the instructions there – starting simple, with add, subtract, compare, move, copy by students working by hand with small numbers, switching to the Rodrego simulation for more complex operations with larger numbers. The point being to notice that these ever more onerous tasks are still being performed with the same basic steps AND that since registers represent not just the values being processed, but also the instructions and indeed names of whole sets of instructions (ie programs). Dennett’s six lessons are made explicit in the Seven Secrets exercise, as the student learns increasing sophistication and complexity is simply more layers or more of the same 3 basic RAP steps.

[Apart from the bucket of chips and chairs for the students to arrange themselves on, the main resource to be developed is the teaching guide version of the above description. Some trial cases or visual recordings using the actual physical arrangements will help in achieving this?]

Additional Considerations and Follow-up Questions.

The exercise builds from simple beginnings. Pedagogically the intended lessons are the Seven Secrets, but the learning also needs to develop the appreciation that the secrets are (a) real and (b) of deep and wide significance – to computing and more wider aspects of computation.

How much can be achieved from one session or set of sessions obviously depends on the initial competencies and receptivity of the students. Achieving practical demonstration of all 6 rules depends on moving to the simulated exercise after the first 3 or 4 simple hands-on programs, and recognising that we are simply extrapolating from the hands-on reality.

If that point of knowing and understanding the Seven Secrets is achieved, appreciating their significance and the widest range of possible consequences is open ended. Different areas of interest can be stimulated by follow-up questions and exercises. Some related to real physical computing devices, languages, programs and real world business and industrial applications, and some related to the deeper significance of computation itself in the biological and cognitive fields as well as fundamental physics.

[This is a work-in-progress proposal to develop teaching resources to make use of the Dennett materials. It is shared in this form to elicit comments and/or inputs for how that can be done to achieve an effective teaching resource or set of resources. Comments are invited?]

======

Lots of possible follow-up questions:

[The six (seven) rules themselves – in a computer context – significance for scalability of size and complexity, and where performance and practical constraints might lie – clue, not in the fundamental rules.]

Need care not to fall into trap of “mechanistic” machine thinking – especially given the convergent areas suggested (Dennett himself warns of too greedy reductionism): So?

[Machine – not just physical machines, nor even “virtual machines” running on physical computer servers but any algorithmic system in any context or medium.]

[Algorithm – as a concept. Limits to “machine” views of biology and neuro-science?]

[“Bits” in the exercise – might suggest only digital computation? But what about analogue and quantum machines. How can the rules still apply.]