Simplified Programming Model

Ein simplifiziertes Bild des Programmierens

Stellen wir uns einen gewöhnlichen Taschenrechner vor, der Addieren, Subtrahieren, Multiplizieren und Dividieren, sowie sich in einigen Speicherregistern ein paar Zahlen merken kann. In einer übersimplifizierten Sicht (die wir in Kürze wieder über Board werfen) können wir uns einen Computer als Taschenrechner vorstellen, der seine eigenen Tasten drücken kann. Ein Computerprogramm ist dann lediglich eine Liste von Anweisungen, die dem Computer sagen, welche Tasten er wann drücken soll (es gibt sogar tastenprogrammierbare Taschenrechner die genau auf diese Art funktionieren).

Nun soll unser Rechner folgende Aufgabe ausführen:

Aus einer gegebenen Liste von Zahlen soll der Mittelwert errechnet und zusätzlich die größte Zahl herausgefunden werden.

Your instructions might look something like this:

"We're going to use memory register 1 to store the running total of all the numbers, memory register 2 to store how many numbers we've seen, and register 3 to store the largest number we've seen. For each number in the input list, add it to register 1. Add 1 to register 2. If the number you just read is larger than the number in register 3, store it in register 3. When you've read all the numbers, divide register 1 by register 2 to compute the average, and also retrieve the largest number from register 3."

Wir stellen uns nun vor, dass wir dem Rechner eine Liste von Anweisungen zur Erfüllung der Aufgabe geben. Oder wir geben diese Liste einer sehr dummen aber geduldigen Versuchsperson, die Anweisungen blind aber exakt ausführen kann, solange es sich lediglich um das Drücken bestimmter Tasten des Rechners oder einfache ja/nein-Entscheidungen handelt (Für unsere Zwecke eignet sich die eine Annahme so gut wie die andere).

Die Anweisungen könnten nun folgendermaßen aussehen:

"Das Register 1 soll verwendet werden, um die laufende Summe der Zahlen zu speichern, Register 2 soll die Anzahl der bearbeiteten Zahlen speichern und Register 3 speichert die größte der bearbeiteten Zahlen. Für jede Zahl aus der Liste ist folgendes zu tun: addiere sie zu Register 1; addiere 1 zu Register 2; wenn die Zahl größer ist als die Zahl in Register 3, speichere sie in Register 3. Wenn alle Zahlen gelesen sind, dividiere Register 1 durch Register 2 um den Mittelwert zu errechnen und hole die größte Zahl aus Register 3.

1. The first sentence, which explains what the registers are used for, is more for our benefit than the entity who will be pushing the buttons on the calculator. The entity pushing the buttons doesn't care what the numbers mean, it just manipulates them as directed. Similarly, the words "to compute the average" and "largest" in the last sentence are extraneous; they don't tell the entity pushing the button anything it needs to know (or that it can even understand).

Zur obigen Liste von Befehlen ist nun einiges anzumerken:

1. Der erste Satz, der beschreibt wofür die Register verwendet werden, dient mehr unserem eigenen Interesse als dem Akteur, der die Tasten des Rechner drückt. Für den tastendrückenden Akteur ist es nämlich einerlei, was die Zahlen bedeuten, er manipuliert sie einfach nur unmittelbar. Das gleiche gilt im letzten Satz für die überflüssigen Worte "um den Mittelwert zu errechnen" und "größte" die dem Akteur nichts notwendiges mitteilen (und die er unter Umständen auch gar nicht versteht).

[21] 2. The instructions use the word "it" several times. Even in English, where we're used to a certain amount of ambiguity which we can usually work out from the context, pronouns like "it" can cause problems in sentences, because sometimes it isn't obvious what they mean. (For example, in the preceding sentence, does "they" refer to "pronouns," "problems," or "sentences?") In programming, you can never get away with ambiguity; you have to be quite precise about which "it" you're referring to.

3. The instructions are pretty vague about the details of reading the next number in the input list and detecting the end of the list.

2. Die Anweisungen enthalten einige Male das Wort "sie". Sogar in unserer natürlichen Sprache - die ein gewisses Maß an Mehrdeutigkeit verträgt, die wir aus dem Zusammenhang richtig interpretieren - können Fürwörter wie "sie" in Sätzen zu Problemen führen, denn manchmal ist nicht offensichtlich, worauf sie sich beziehen (z. B. ist im voranstehenden Satz nicht ganz klar, ob sich "sie" auf "Fürwörter", "Sätze" oder "Probleme" bezieht). Beim Programmieren kann man sich solche Mehrdeutigkeiten nicht leisten, wir müssen absolut präzise sagen, worauf wir uns beziehen.

3. Die Anweisungen sind auch ziemlich vage, was die detailierte Beschreibung des Lesens der Zahlen betrifft und wie das Ende der Zahlenliste erkannt werden soll.

[22] 4. The "program" contains several bugs! It uses registers 1, 2, and 3, but we never say what to store in them in the first place. Unless they all happen to start out containing zero, the average or maximum value computed by the "program" will be incorrect. (Actually, if all of the numbers in the list are negative, having register 3 start out as 0 won't work, either.)

Das "Programm" enthält auch einige Fehler! Wir verwenden die Register 1, 2 und 3, aber sprechen nicht darüber, welche Werte sie anfangs enthalten sollen. Wenn sie nicht zufälliger- und glücklicherweise alle den Wert 0 enthalten, wird der vom "Programm" errechnete Mittelwert oder der Maximalwert falsch sein (Tatsächlich würde ein Wert 0 in Register 3 nicht einmal unbedingt zum richtigen Maximalwert führen, dann nämlich, wenn sämtliche Zahlen der Liste negativ sind).

Hier ist nun eine detailiertere Version des "Programmes", das auf überflüssige Informationen verzichtet, Mehrdeutigkeiten vermeidet, die Handhabung der Zahlenliste ein bisschen präziser beschreibt und wenigstens einige Fehler vermeidet (Um den Passus "die zuletzt gelesene Zahl" eindeutig zu machen, speichert sie das "Programm" in Register 4, statt sich mit "sie" auf die Zahl zu beziehen. Weiters gehen wir vorläufig davon aus, dass die Zahlenliste keine negativen Zahlen enthält).

[24] "Store 0 in registers 1, 2, and 3. Read the next number from the list. If you're at the end of the list, you're done. Otherwise, store the number in register 4. Add register 4 to register 1. Add 1 to register 2. If register 4 is greater than register 3, store register 4 in register 3. When you're done, divide register 1 by register 2 and print the result, and print the contents of register 3."

"Speichere 0 in die Register 1, 2 und 3. Lies die nächste Zahl aus der Liste. Falls keine ungelesene Zahl mehr vorhanden ist, sind wir fertig. Andernfalls, speichere die Zahl in Register 4. Addiere Register 4 zu Register 1. Addiere den Wert 1 zu Register 2. Wenn Register 4 größer ist als Register 3, speichere Register 4 in Register 3. Wenn wir fertig sind, dividiere Register 1 durch Register 2 und drucke das Ergebnis. Drucke den Inhalt von Register 3."

Beim Hinzufügen des Initialisierungschrittes (dem Speichern von 0 in den Registern), bemerken wir, dass es nicht ganz offensichtlich ist, welche Schritte nur ein einziges mal und welche einmal pro Zahl der Liste (d. h. einmal pro Durchlauf der Verarbeitungsschleife) ausgeführt werden sollen. Wir haben auch angenommen, dass wir die Rechenoperationen direkt in den Registern durchführen können. Wenn wir die Schleifengrenzen deutlicher sichtbar machen und die Rechnungen vereinfachen (angenommen der Rechner kann Registerinhalte nur vom Display speichern bzw ins Display abrufen und nur im Display rechnen), dann werden die Anweisungen noch ausführlicher:

[26] "Store 0 in register 1. Store 0 in register 2. Store 0 in register 3. Here is the start of the loop: read the next number from the list. If you're at the end of the list, you're done. Otherwise, store the number in register 4. Recall from register 1, recall from register 4, add them, store in register 1. Recall from register 2, add 1, store in register 2. Recall from register 3, recall from register 4, if greater store in register 3. Go back to the beginning of the loop. When you're done: recall from register 1, recall from register 2, divide them, print; recall from register 3, print."

"Speichere 0 in Register 1. Speichere 0 in Register 2. Speichere 0 in Register 3. Hier ist der Schleifenanfang: Lies die nächste Zahl aus der Liste. Falls keine ungelesene Zahl mehr vorhanden ist, sind wir fertig. Andernfalls, speichere die Zahl in Register 4. Register 4 abrufen. Register 1 Abrufen. Addieren und in Register 1 speichern. Register 2 abrufen, Wert 1 addieren, in Register 2 speichern. Register 3 abrufen. Register 4 abrufen. Wenn größer, in Register 3 speichern. Gehe zurück zum Schleifenanfang. Wenn wir fertig sind: Register 1 abrufen, Register 2 abrufen. Dividieren. Drucken. Register 3 abrufen. Drucken."

Wir könnten nun unsere Anweisungliste weiter bis ins letzte Detail verfeinern, aber der wesentliche Punkt ist hoffentlich klargeworden: Die beim Programmieren verwendeten Anweisungen müssen sehr präzise sein, und ein Maß an Detailreichtum und Kleinlichkeit aufweisen, das im normalen Leben nicht vorkommt. (Genau genommen ist die Situation nicht ganz so schlimm wie in unserem Beispiel, das schon mehr in Richtung auf das Programmieren in Assembler weist. In höheren Programmiersprachen wie C braucht man sich nicht mehr um die Zuordnung von Registern oder einzelne arithmetische Arbeitsschritte zu kümmern.)

Reale Computer können einiges mehr, als ein simpler Taschenrechner mit seinen 4 Grundrechnungsarten; z. B. können sie Texte verarbeiten und mit andere Daten als nur mit Zahlen umgehen. Wir vergessen jetzt den Taschenrechner und schauen uns an, was reale Computer (zumindest wenn sie von Programmiersprachen wie C gesteuert werden) leisten können.