Regularity
From Maze
The Grid: Regularity in Space
Repeating: Regularity in Time and Process
The Flow of Control
In any imperative programming language, commands are processed in a particular order that relates to the left-to-right, then top-to-bottom path that the Western reader's eyes stereotypically take along a page. If one types in two PRINT commands directly to the Commodore 64's BASIC interpreter, with a colon between them, like so:
PRINT "FIRST": PRINT "SECOND"
The result is
FIRST SECOND
The command on the left is executed first; then, probably not very surprisingly, the command on the right is carried out. In executing the following program, the topmost, leftmost command is run first, then the one to the right, and then the one on the next line, so that three lines that read FIRST, SECOND, and THIRD are printed:
10 PRINT "FIRST": PRINT "SECOND" 20 PRINT "THIRD"
The order in which these two lines are actually typed in by the programmer is completely irrelevant to how the program runs. The lines of a BASIC program are executed based on their line numbers, not based on when lines were entered.
There are some important ways to complicate this straightforward program flow. All of these ways involve branching, which causes program flow to continue at some other command rather than what would is, according to left-to-right, top-to-bottom program structure, the next one.
Conditional and Unconditional Branching
At a low level, an executing program can either continue to process the next instruction or can move out of sequence to process a different instruction. Just as a reader of a text will typically move to the next word or line, the usual case in the execution of a program is to move to the next instruction. This involves incrementing the program counter so that it points to the place where code is located in memory. If the current instruction is one that can change the flow of control, however, the program may jump or branch to a new memory location and a new piece of code.
There are two ways to branch. An unconditional branch always directs the program to jump to a new location, like the instruction "Go directly to Jail -- do not pass Go" in Monopoly. The assembly mnemonic for an unconditional branch is JMP; the corresponding BASIC keyword is GOTO.
When an unconditional branch is used to point back to an earlier instruction, it can accomplish repetition in process. In 10 PRINT, the GOTO command is used to cause the program to loop, so that the PRINT command is repeated again and again.
The other type of branch is a conditional branch, a type of instruction that is critical to general-purpose computing. There are many different types of conditional branches in assembly, since there are many different types of conditions. BEQ is "branch if equal," for instance; when used after a comparison (CMP), the branch will be taken only if the compared values are equal. BMI, "branch if minus," checks to see if the last computation resulted in a negative value. In BASIC, using the IF ... THEN statement is the most straightforward way to accomplish a conditional branch, as this program demonstrates:
10 INPUT A$ 20 IF A$ = "1" THEN PRINT "ONE" : END 30 PRINT "SOMETHING ELSE"
If, after running this program, the user types just the digit "1" and then presses RETURN, all of the statements on line 20 will be executed. "ONE" will be printed and then the program will terminate as END instructs. If the user types anything else before pressing RETURN, the flow of control moves to line 30 and PRINT "ONE" and END are skipped. "SOMETHING ELSE" is printed instead.
Although there is no IF ... THEN statement in 10 PRINT, and the program does not by any interpretation contain a conditional branch, this short program does accomplish a very small-scale sort of variation. By computing 205.5+RND(1) and passing that value to the function CHR$, the program prints either PETSCII character 205 or PETSCII character 206. This variation between two characters is a one-bit variation, a selection from the smallest possible set of options. Yet, in combination with the regularity of a repeating processes and the regularity of the Commodore 64's screen grid, these selections take shape as something evocative and visually interesting.
This all needs reworking...
Perhaps the single most important programming idea is that of a loop. - BASIC: A Manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System, 1 October 1964
GOTO and the Unbounded Loop
10 PRINT works as it does because of its repetition of the PRINT statement, repetition that is unconditional: It will continue until something outside the program interrupts it.
At a high level, programs can contain two types of loops: bounded (also called "finite") and unbounded (or "infinite"). 10 PRINT has the latter kind, an infinite loop. If one is writing a program that is intended to exit and to produce some result, an unbounded loop represents a mistake on the programmer's part. The unbounded loop does have legitimate uses, however. It can be used to keep an application, usually an interactive one, running and accepting input until the system is shut off or rebooted. This can be done even on a single-threaded system such as the Commodore 64.
Bounded loops are those that end under certain conditions. The exact conditions vary; some will continue until the program reaches a pre-defined exit state while others execute a specific number of times no matter what the result. No matter what the exit conditions are for a specific loop, the fact that there are exit conditions at all implies the programmer is expecting some kind of change in the program to be introduced as the program executes.
A common use of finite loops is to create an iterative process. Iteration is a special type of loop where the result of one pass through the loop influences the result of succeeding passes. The simplest example of an iterative process is nothing more than counting. Beginning with an initial value, 1, and adding 1 to it to produces 2. Taking the output from that operation, 2, and performing the same operation again, adding 1, results in 3, and so on until the sequence 1, 2, 3… emerges. Counting to 10, 100, or for one hour no matter what number you end up at are all finite iterative processes; counting until you pass out is an infinite iterative process, even if you never quite make it to infinity.
Is the Program Iterating?
Based on this description of iteration, it may not be entirely clear that 10 PRINT is an example of iteration. There are no variables in the code that change value from one pass to the next–there are no variables at all–and the functionality of the code inside the loop never changes. Watching the program execute on screen shows hints that there is something changing beneath the surface, though: the position of the cursor changes every time the loop executes, moving one position to the right.
The position of the cursor is not being managed by 10 PRINT itself; it is a function of the Commodore 64's kernal, a layer of software that lies between BASIC and the machine code executed by the processor to handle input/output functions. Since 10 PRINT's BASIC code is not controlling the iterative aspect of its function it would be accurate to say that 10 PRINT is operationally iterative, but the BASIC code is not. This should not preclude examination of 10 PRINT's iterative nature, however; many iterative processes are dependent upon external or implicit factors influencing their output, and 10 PRINT's simplicity exposes the power of using simple iterative steps to create a complex construction.
(tk not sure if it would be confusing here to describe RND as an iterative process since it is deterministic...RND(1) is little different than iterating through a stored list of numbers...)
FOR ... TO ... STEP
(tk add variant that rewrites 10 PRINT to manually manage the cursor position by poking specific grid locations using BASIC's built-in iteration structure.)
Iteration Permeates Computing
Transistors and processors
If you zoom in far enough all a computer ever does is run one iterative loop after another, up to five hundred thousand times per second in the Commodore 64's MOS Technologies 6510 processor and billions of times per second in a modern chip. The iterations are not just restricted to processors though: almost every component in the computer, including memory, input/output controllers, and video adapters are all constantly iterating, no matter what code the programmer writes or the user runs. Digital logic is based on the idea that general-purpose instructions can be modeled using nothing more than ones and zeros, but the ones and zeros must themselves be modeled somehow before they can turn into digits, logic, or characters on a screen.
Computers do one thing well...
At a literally nanoscopic level, a computer is little more than a collection of switches. Lots of switches, really: a few hundred per square millimeter in the Commodore 64's day, and millions per square millimeter using today's most advanced lithographic techniques. (tk footnote Moore's Law?) But unlike a light switch, the transistors used as switches in digital devices are not operated by physically flipping a conductor to complete a circuit. Transistors are solid-state electronics made of semiconducting materials that, depending on an input signal, either allow or prevent the flow of current through a junction. The difference between no current and full current is thought of as the difference between a zero and a one, a false and a true, or an off and an on.
As they are built largely from transistors, computers are devices that do one thing very, very well: they can detect the difference between no current and some current. Despite the power represented by making millions of simple decisions per second, this principle of operation also presents a problem. With no physical components to move and create or break a circuit, a single transistor will not "remember" whether it should be allowing current to flow or not without a constant input signal. Without that bit of memory, a transistor can only ever allow a signal to pass through it; if it is to be useful in logic, it must somehow be made to capture the output of that signal and combine it with the signals coming from other transistors on the chip to perform complex operations.
Memory and CPUs
Depending on which is best for the application at hand, there are several ways to construct a circuit around a transistor that will allow it to behave as a useful logical switch. The most basic is to simply offload that responsibility to another part of the integrated circuit. This approach is often taken in parts of a microprocessor that are intended to carry out the actual work of computing, such as the arithmetic logic unit (ALU). An ALU is a series of transistors organized into logic gates – simple circuits that compare two input voltages and produce an output based on comparing them to see if they are the same or different. (tk footnote Boolean logic) The simple logic gates are ganged together to allow multiple inputs to undergo relatively complex operations and produce multiple outputs. Within the gates, though, the data is simply used and then lost, transformed into an output.
In practice, an ALU is rarely complex enough to accomplish large tasks in a single pass. Since the logic gates must be reused to calculate the results of subsequent passes, storing the results of the first pass is relegated to an accumulator. The accumulator in the Commodore 64's 6510 chip is a memory register that holds the results of a previous calculation until they are fed back into the ALU as one of its inputs for a future calculation. This process, which takes place entirely at the level of transistors, is an iterative function: a process that repeats continuously, using the output of previous passes as an input for the next one.
Pushing storage off into a register does not truly solve the problem of how to make transistors remember states though; it only moves it to another part of the chip. Inside the registers is where the problem must be truly solved, and again the answer uses an iterative loop. The same logic gates that perform calculations in the ALU can be reconfigured into a circuit called a flip-flop. There are many different types of flip-flops, but what they have in common is that they use several transistors to create a positive feedback loop where the state of each transistor switch is reset every clock cycle to be equal to what it was in the previous cycle. An external voltage drives the entire loop and the state of the output is only changed when the state of an input changes. Though it appears from the outside that the state of the flip-flop is constant, the iterative cycle of setting a high or low output voltage based on whether the voltage was high or low in the previous cycle is what gets around the lack of a physical switch. (tk need to specify latches?)
Further away from the heart of the processor, another type of memory also uses iterative cycles to simulate a constant state. Dynamic Random Access Memory (DRAM) is a simpler but slower solution that uses far fewer transistors than the flip-flops in the processors. Instead, DRAM fills a capacitor with electrons to represent a high state. The capacitor quickly discharges though, returning it to a low state. Before it can discharge completely, control circuitry checks to see if it was full on the previous clock cycle and immediately refills the capacitor, effectively creating a loop that holds a state until the memory loses power.
Example: Adding with an Accumulator
(This section will be done with a diagram.)
Iteration – code and structures
"Go To Statement Considered Harmful"
In the case of 10 Print the GOTO statement avoids most of Dijkstra's complaints. Putting a GOTO statement at the end of a one-line program that simply references itself does not leave much room for unexpected entrances and exits. However, expanding the program to take more than one line demonstrates the potential problems that GOTO introduces:
5 CHARCODE%=205.5+RND(1) 10 PRINT CHR$(CHARCODE%); 20 GOTO 5
This code is functionally identical to the one-line version of 10 Print, but is a bit more representative of how developers create more complex programs. Line 5 creates a variable called CHARCODE% that stores a character code determined by the same formula used in the original 10 Print, but the character code is not used until line 10 when it is printed to the screen. Line 20 has the GOTO statement that makes the program iterate, but it now points to the new beginning of the program at line 5.
Already there is one potential problem: what if the programmer had forgotten to change GOTO's target from line 10 to line 5? The program would still function, but since the loop only returns to line 10 CHARCODE% never changes and the program only prints the same character over and over again with no randomization. Nowhere in this code does it say that the computer must select a random character code every time it prints a character, it is only implied by the fact that line 10 comes after line 5. GOTO allows the programmer to reference any line of code, however; it is just as valid to say GOTO 10 as it is GOTO 5, regardless of the intention that line 10 always executes right after line 5. GOTO's ability to target arbitrary line numbers means that sections of code that are intended to be monolithic can be entered at any point instead of just the beginning of the block.
GOTO's potential problems only get worse when it is combined with other flow control statements. Consider this variant of 10 Print:
1 FOR I = 0 TO 999 5 CHARCODE%=205.5+RND(1) 10 POKE 1024+I,CHARCODE% 15 NEXT I 20 GOTO 1
This version uses a FOR loop to fill the entire screen with the two 10 Print characters, beginning at the top-left corner. Immediately after finishing the FOR loop the program hits line 20 and GOTO sends execution back to line 1, restarting the loop from the beginning. If the forgetful programmer again fails to update line 20 though, leaving it as:
20 GOTO 5
The program will now not only fail to work as intended, it will fail to work at all and throw an error:
? NEXT WITHOUT FOR ERROR IN 15
Unlike the previous version where lines 5 and 10 were only implied to be a block, lines 1-15 are now explicitly a block of code defined as a FOR loop. NEXT relies on FOR, but since the block was re-entered on line 5 FOR never executes and NEXT is no longer valid. Using GOTO has short-circuited the other flow control structures that are critical to the language.
(tk may be clearer with diagram?)
Structured programming
Dijkstra's comments about GOTO were part of a movement toward programming languages that are designed for structured programming. Dijkstra himself would later take the idea further in his Notes on Structured Programming. Instead of viewing a program as line after line of text, structured programming practices involve seeing a program as an abstract set of tasks to be completed. Each of these tasks can be completed independent of one another; one section of the program can be written without worrying about how it is going to reference other sections because they share a common method of moving data between them. At a high level, programmers do not need to worry about how each function will work, they just know that it will and this knowledge allows them to plan their code strategically. Dijkstra compared this model to a string of pearls:
One of the metaphors in which I find myself thinking about the program structure envisaged regards the programs as a necklace, strung from individual pearls. We have described the program in terms of levels and each level contained "refinements" of entities that were assumed available in higher levels. […] I use the term "pearl" for [individual functions].
OOP
Recursion
Design and feedback
Iterative design
Testing as development
Agility and reuse
= Iteration – software and business=
Mechanical reproduction
Version 1.0
Break
Iteration as a Generalized Process
Bread and Beer
Fractals and Chaos
Life
Works Cited
Anon. 1964. BASIC. Dartmouth College: Computation Center.
