Teaching Programming and Algorithmic Complexity with Tangible Machines

Abstract

Understanding the notional machine that conceptually executes a program is a crucial step towards mastery of computer programming. In order to help students build a mental model of the notional machine, visible and tangible computing agents might be of great value, as they provide the student with a conceptual model of who or what is doing the actual work. In addition to programming, the concept of a notional machine is equally important when teaching algorithmic design, complexity theory, or computational thinking. We therefore propose to use a common computing agent as notional machine to not only introduce programming, but also discuss algorithms and their complexity.

Appendices

A Python Programs

 

B Quicksort

For Quicksort, the turtle assumes the colour of the first dot it encounters, and then compares the colours of all subsequent dots to its own colour (the pivot colour). Dots with a colour hue that is smaller (or equal) are placed to the left, those with larger colour hue are placed to the right (see Program 4 and Fig. 3). As long as more than one dot remains in any stack, the procedure is repeated recursively.

Fig. 3.

In our implementation of Quicksort, the turtle takes the colour of the first dot at the bottom as the pivot. It then moves all dots either to the left or to the right, creating two new columns to be sorted afterwards. (Color figure online)

Fig. 4.

An alternative implementation of Quicksort, where the dots are arranged horizontally. Each pivot colour is dropped to the bottom after the sorting step: due to the gap between the left and the right hand side, its position in the result is already known. At the very bottom, the final solution is shown. (Color figure online)

Instead of arranging the dots as vertical stacks as in Fig. 3, it is also possible to arrange the coloured dots as horizontal lines as in Fig. 4. Note that the line on the right side grows from right to left, leading to the order of the dots being reversed on each step. Since the pivot dot is neither added to the left, nor the right hand side, a gap forms in between the two sides. While an implementation without additional variables is, in principle, feasible, the search for the right spot to place the new dot might take a large amount of both program code, and execution time.

So far, we have never progressed in class enough to actually discuss Python code of Quicksort as shown in Program 4. The use of recursion makes a discussion on entry level difficult (it is possible to do it without recursion, but this does not necessarily lead to better understandable program code). However, we have presented the horizontal version several times as a basis for further discussion, with great results: students often realised, for instance, that the algorithm works best if the pivot colour divides the dots into two lines, or piles, of approximately equal size, and fails to be efficient for dots, “which are sorted in reverse” (it seems that the idea of sorting an already sorted line does not necessarily occur to high school students).