Steve Summit / Teil5
StartSeite | SteveSummit/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Top
Prev
Next
Simplified Programming Model
- Ein simplifiziertes Bild des Programmierens
[18] Imagine an ordinary pocket calculator which can add, subtract, multiply, and divide, and which has a few memory registers which you can store numbers in. At a grossly oversimplified level (so simple that we'll abandon it in just a minute), we can think of a computer as a calculator which is able to push its own buttons. A computer program is simply the list of instructions that tells the computer which buttons to push. (Actually, there are "keystroke programmable" calculators which you program in just about this way.)
Imagine using such a calculator to perform the following task:
Given a list of numbers, compute the average of all the numbers, and also find the largest number in the list.
- 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.
[19] You can imagine giving the calculator a list of instructions for performing this task, or you can imagine giving a list of instructions to a very stupid but very patient person who is able to follow instructions blindly but accurately, as long as the instructions consist of pushing buttons on the calculator and making simple yes/no decisions. (For our purposes just now, either imaginary model will work.)
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.
[20] There are several things to notice about the above list of instructions:
- 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).
[23] Here is a somewhat more detailed version of the "program", which removes some of the extraneous information and ambiguity, makes the input list handling a bit more precise, and fixes at least some of the bugs. (To make the concept of "the number just read from the list" unambiguous, this "program" stores it in register 4, rather than referring to it by "it." Also, for now, we're going to assume that the numbers in the input list are non-negative.)
- 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."
[25] When we add the initialization step (storing 0 in the registers), we realize that it's not quite obvious which steps happen once only and which steps happen once for each number in the input list (that is, each time through the processing loop). Also, we've assumed that the calculator can do arithmetic operations directly into memory registers. To make the loop boundaries explicit, and the calculations even simpler (assuming that all the calculator can do is store or recall memory registers from or to the display, and do calculations in the display), the instructions would get more elaborate still:
- 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."
[27] We could continue to "dumb down" this list of instructions even further, but hopefully you're getting the point: the instructions we use when programming computers have to be very precise, and at a level of pickiness and detail which we don't usually use with each other. (Actually, things aren't quite as bad as these examples might suggest. The "dumbing down" we've been doing has been somewhat in the direction of assembly language, which wise programmers don't use much any more. In a higher-level language such as C, you don't have to worry so much about register assignment and individual arithmetic operators.)
- 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.)
[28] Real computers can do quite a bit more than 4-function pocket calculators can; for one thing, they can manipulate strings of text and other kinds of data besides numbers. Let's leave pocket calculators behind, and start looking at what real computers (at least under the control of programming languages like C) can do.
- 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.
Top
Prev
Next
StartSeite | SteveSummit/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 29. Mai 2002 21:17 (diff))