Informatisches Denken und Problemlösen

Ein Computer kann eine Route berechnen, einen Ton abspielen oder eine Liste von Namen ordnen. Die Informatik untersucht die Abläufe hinter diesen Aufgaben: wie Informationen dargestellt und verarbeitet werden, welche Probleme lösbar sind und wie sich Systeme bauen lassen, die die Lösungen ausführen.

Eine Berechnung beschreiben

Ein nützliches Ausgangsmodell ist Eingabe → Verarbeitung → Ausgabe. Ein Routenplaner erhält einen Startpunkt und ein Ziel. Er durchsucht Informationen über Straßen und gibt dann eine Route, eine Entfernung in Kilometern und eine Fahrzeit zurück. Die Straßeninformationen sind ebenfalls Daten, die die Verarbeitung benötigt. Das sichtbare Ergebnis ist nur ein Teil der Berechnung.

Beschreibe ein Berechnungsproblem, bevor du das Verfahren auswählst. Zum Beispiel: „Eingabe: eine Liste von Namen. Ausgabe: dieselben Namen in alphabetischer Reihenfolge.“ Das legt fest, wie ein korrektes Ergebnis aussehen muss. Es lässt Raum für verschiedene Verfahren, um es zu erzeugen. Fehlt in der Ausgabe ein Name, erfüllt sie die Aufgabe nicht, auch wenn die übrigen Namen geordnet sind.

Mehr als Code schreiben

Programmierung bedeutet, Anweisungen in einer Sprache zu schreiben, die ein Computer ausführen kann. Sie ist eine wichtige Tätigkeit innerhalb der Informatik. Das weiter gefasste Fachgebiet fragt auch, ob eine Lösung existiert, wie viel Arbeit sie benötigt und wie Menschen sie sicher und einfach nutzen können.

Die Gebiete überschneiden sich. Beim Entwurf eines Bildbearbeitungsprogramms können gleichzeitig Computergrafik, Benutzerinteraktion und Softwaretechnik eine Rolle spielen. Informatik unterstützt auch andere Fachgebiete: Biologinnen und Biologen vergleichen DNA-Sequenzen, Klimaforschende modellieren die Atmosphäre und Kunstschaffende nutzen Software, um Bilder und Musik zu schaffen.

Verwandte Gebiete und praktische Grenzen

Die Technische Informatik konzentriert sich auf physische Geräte wie Prozessoren und Platinen. Die Informationstechnologie, kurz IT, konzentriert sich auf die Auswahl, Einrichtung und den Betrieb von Systemen für eine Organisation. Data Science verbindet Statistik und Informatik, um aus Daten Schlussfolgerungen zu ziehen. Diese Gebiete teilen Methoden mit der Informatik, setzen aber unterschiedliche Arbeitsschwerpunkte.

Computer führen genaue Anweisungen schnell aus, oft Milliarden einfacher Operationen pro Sekunde. Geschwindigkeit behebt keine unklare Anweisung. „Gib etwas Salz hinzu“ lässt eine Mengenangabe offen; ein Ablauf für die automatische Ausführung benötigt eine genaue Aktion.

Es gibt auch Grenzen, die über die Geschwindigkeit hinausgehen. Manche genau beschriebenen Probleme haben keine algorithmische Lösung. Andere Probleme haben Lösungen, die zu viele Schritte erfordern, um praktisch durchführbar zu sein. Die Frage, was ein Computer leisten kann, gehört zur Informatik selbst.

Informatisches Denken klärt ein Problem so weit, dass es sich Schritt für Schritt lösen lässt. Ein Mensch oder ein Computer kann die Lösung ausführen, oder beide teilen sich die Arbeit. Zum Denken gehört, zu entscheiden, was das Problem bedeutet und wie ein Ergebnis überprüft werden soll.

Vier Techniken, die zusammenwirken

Die Problemzerlegung teilt ein Problem in kleinere Teile. Die Mustererkennung findet Ähnlichkeiten oder wiederholte Arbeit. Die Abstraktion behält die für einen Zweck nötigen Details und lässt andere weg. Der Algorithmenentwurf überführt eine Lösung in genaue, geordnete Schritte.

Diese Techniken sind Werkzeuge, auf die du bei Bedarf zurückgreifen kannst. Es sind keine vier Kästchen, die in einer festen Reihenfolge abgearbeitet werden müssen. Ein fehlgeschlagener Test kann ein fehlendes Teilproblem aufdecken. Ein wiederkehrendes Teilproblem kann auf eine wiederverwendbare Prozedur hinweisen. Ein Modell benötigt vielleicht ein weiteres Detail, bevor der Algorithmus funktionieren kann.

Jeannette Wing trug 2006 mit einem Aufsatz dazu bei, den Begriff „informatisches Denken“ weithin bekannt zu machen. Ihre zentrale Aussage war, dass dieser Ansatz für alle nützlich ist und nicht nur für Menschen, die als Programmierende arbeiten.

Verstehen, planen, ausführen und überprüfen

Der Mathematiker George Pólya beschrieb 1945 vier Phasen des Problemlösens. In der Informatik führen sie zu konkreten Handlungen:

1. Verstehe das Problem. Ermittle Eingaben, Ausgaben, Nebenbedingungen und Erfolgskriterien.
2. Erstelle einen Plan. Wähle kleinere Aufgaben, nützliche Muster und einen Algorithmus.
3. Führe den Plan aus. Stelle ihn mit Pseudocode, einem Programmablaufplan oder einem Programm dar und führe ihn aus.
4. Blicke zurück. Vergleiche das Ergebnis mit den Erfolgskriterien und überarbeite die Lösung bei Bedarf.

Eine Nebenbedingung ist eine Regel, die die Lösung einhalten muss, etwa eine maximal verfügbare Zeit. Ein Erfolgskriterium ist eine Möglichkeit, das Ergebnis zu beurteilen. „Erstelle eine zusammengefasste Einkaufsliste mit den benötigten Mengen“ lässt sich überprüfen. „Verbessere den Einkauf“ lässt das Ergebnis unklar.

Einen Speiseplan durcharbeiten

Angenommen, du brauchst Abendessen für eine Woche. Zu den Eingaben gehören die Rezepte, die Anzahl der Personen und bereits vorhandene Lebensmittel. Die Ausgabe ist ein Plan und eine Einkaufsliste. Ernährungsbedürfnisse und die verfügbare Kochzeit sind Nebenbedingungen.

Zerlege die Arbeit in das Auswählen der Gerichte, das Erstellen der Liste und das Kochen. Die Mustererkennung zeigt, dass mehrere Rezepte Reis und Zwiebeln verwenden. Die Abstraktion stellt eine Zutat durch ihren Namen und ihre Menge dar, etwa „Reis, 1 kg“, ohne einen Markennamen zu behalten, wenn die Marke den Plan nicht beeinflusst.

Der Einkaufsalgorithmus lässt sich nun ordnen: Gerichte auswählen, ihre Zutaten auflisten, wiederkehrende Zutaten zusammenfassen, den vorhandenen Vorrat abziehen und den Rest einkaufen. Wenn du die Mengen vor der Prüfung des Vorratsschranks zusammenfasst, wird derselbe Vorrat nicht für jedes Rezept einzeln abgezogen.

Prüfe das Ergebnis anhand der Gerichte. Jede benötigte Zutat muss in ausreichender Menge verfügbar sein. Fehlt eine Zutat, verfolge nach, wie die Liste erstellt wurde, und überarbeite den betreffenden Schritt.

Ein häufiger Fehler ist, mit dem Programmieren zu beginnen, bevor feststeht, welches Ergebnis benötigt wird. Ein schnelles Programm kann das falsche Problem exakt lösen. Die Menschen wählen weiterhin das Modell, die Nebenbedingungen und die Schritte; der Computer führt die Anweisungen aus, die diese Entscheidungen ausdrücken.

Ein großes Problem kann schwer auf einmal zu überblicken sein. Die Problemzerlegung ersetzt es durch kleinere Teilprobleme, die du getrennt verstehen, lösen und überprüfen kannst. Die Teile müssen sich weiterhin zu einer Lösung des ursprünglichen Problems zusammenfügen lassen.

Vom Ganzen zu den Details arbeiten

Beginne mit der Hauptaufgabe. Teile sie in einige sinnvolle Aufgabenbereiche und verfeinere dann jeden Bereich. Das ist die Zerlegung von oben nach unten. Ein Strukturbaum stellt das ganze Problem oben und die kleineren Aufgaben darunter dar. Die Zweige zeigen, zu welcher Aufgabe eine kleinere Aufgabe gehört.

Bei einer Quiz-App sind die Hauptteile das Speichern von Fragen und Antworten, das Stellen von Fragen, das Prüfen von Antworten sowie das Führen und Anzeigen des Punktestands. Der Teil „Eine Frage stellen“ lässt sich in das Anzeigen des Fragetexts, das Anzeigen der Antwortmöglichkeiten und das Einlesen der Auswahl der lernenden Person zerlegen.

Ein textueller Strukturbaum könnte so aussehen:

Run a quiz
    Store questions and answers
    Ask a question
        Show question text
        Show answer options
        Read the choice
    Check the answer
    Keep and show the score

Diese Zweige beschreiben Aufgabenbereiche. Ihre vertikale Position allein gibt nicht die vollständige Ausführungsreihenfolge an. So wiederholt die App zum Beispiel das Stellen und Prüfen von Fragen, solange noch Fragen übrig sind. Ein eigener Algorithmus beschreibt diesen Ablauf.

Entscheiden, wann die Zerlegung endet

Ein Teil ist klein genug, wenn du direkt erkennst, wie du ihn lösen kannst, oder wenn ein vorhandenes Verfahren oder Werkzeug ihn bewältigt. „Die Auswahl einlesen“ kann eine geeignete Aufgabe sein, sobald du weißt, wie die Schnittstelle Eingaben erfasst. Eine Zerlegung in einzelne Handbewegungen würde Details hinzufügen, die beim Entwurf der App nicht helfen.

Nimm zuerst die Hauptzerlegung vor. Wenn du damit beginnst, winzige Aktionen zu beschreiben, verbringst du leicht viel Zeit mit einem einzelnen Bildschirm und vergisst dabei einen ganzen Aufgabenbereich, etwa die Entscheidung, wann das Quiz endet.

Abhängigkeiten erkennen

Eine Abhängigkeit bedeutet, dass eine Aufgabe das Ergebnis einer anderen Aufgabe benötigt. Das Quiz muss eine Auswahl erhalten, bevor es sie prüft, und sie prüfen, bevor es den Punktestand aktualisiert. Schreibe auf, was jeder Teil erhält und erzeugt. Das macht die Übergaben klar.

Die Teile sollten möglichst unabhängig voneinander sein. Wenn die Anzeige von vier Antwortschaltflächen auf eine andere Eingabemethode umgestellt wird, sollte die Berechnung des Punktestands weiterhin mit dem geprüften Ergebnis funktionieren. Klare Abgrenzungen ermöglichen es, getrennte Teile gleichzeitig zu entwickeln, und erleichtern spätere Änderungen.

Unabhängigkeit bedeutet nicht, dass die Teile niemals Informationen austauschen. Sie benötigen vereinbarte Eingaben und Ausgaben. Ein Teil für die Punktevergabe, der TRUE oder FALSE erwartet, kann den Rohtext eines Teils zur Fragenanzeige nicht direkt verwenden, ohne dass ein Schritt die Antwort prüft.

Nach Lücken und Überschneidungen suchen

Lies das ursprüngliche Problem erneut und frag dich, ob das Erledigen aller Teile die ganze Aufgabe abschließen würde. Der erste Baum zeigt nicht, wann das Quiz endet. Ergänze diese Aufgabe in der übergeordneten Quizsteuerung. Frag dich auch, ob zwei Teile beide den Punktestand ändern und dadurch eine richtige Antwort doppelt zählen könnten.

Prüfe jeden kleinen Teil für sich und anschließend den kombinierten Ablauf. Eine korrekte Fragenanzeige und eine korrekte Antwortprüfung können zusammen dennoch scheitern, wenn der eine Teil die Auswahl in einem anderen Format sendet, als der andere erwartet.

Hinter wiederholter Arbeit verbirgt sich oft ein wiederverwendbares Verfahren. Mustererkennung bedeutet, nach Ähnlichkeiten, Wiederholungen oder Trends innerhalb eines Problems und über verschiedene Probleme hinweg zu suchen. Die hilfreiche Frage lautet, was gleich bleibt und was sich ändert.

Wiederholungen innerhalb einer Aufgabe finden

Um ein Quadrat zu zeichnen, kann sich ein Stift viermal 100 Schritte vorwärts bewegen und um 90 Grad nach rechts drehen. Das Aktionspaar wiederholt sich. Eine Schleife drückt dieses Paar einmal aus und gibt die Anzahl der Wiederholungen vor:

REPEAT 4 TIMES
    Move forward 100 steps
    Turn right 90 degrees

Dieses Muster macht die Struktur leichter erkennbar. Es erleichtert auch eine Änderung: Wenn du die Strecke vorwärts an einer Stelle änderst, ändern sich alle Seiten.

Veränderliche Details durch Parameter ersetzen

Durch Verallgemeinerung funktioniert eine Lösung für eine Familie von Fällen. Ein Parameter ist eine benannte Eingabe, die ein veränderliches Detail darstellt. Bei regelmäßigen Vielecken können die Seitenzahl und die Seitenlänge Parameter sein.

Ein Stift, der ein regelmäßiges Vieleck umrundet, dreht sich insgesamt um eine volle Umdrehung. Die Drehung an jeder Ecke beträgt:

Dabei ist $n$ die Anzahl der Seiten. Wiederhole das Paar aus Bewegung und Drehung $n$-mal und behalte jedes Mal dieselbe Seitenlänge und Drehung bei.

Die Drehung ist die Änderung der Richtung des Stifts, nicht der Innenwinkel des Vielecks. Bei einem Dreieck würde eine Drehung um 60 Grad nicht den beabsichtigten dreiseitigen Weg ergeben.

Dasselbe Verfahren in verschiedenen Problemen erkennen

Beim Finden des günstigsten Flugs, der kürzesten Route und der höchsten Punktzahl in einem Test geht es jeweils darum, sich den bisher besten Kandidaten zu merken. Beginne mit einem Kandidaten. Prüfe jeden nächsten Kandidaten und ersetze den gemerkten, wenn der neue besser ist. Die Richtung des Vergleichs ändert sich zwischen dem kleinsten und dem größten Wert, aber das allgemeine Muster bleibt nützlich.

Muster können auch Daten ordnen. Die Einteilung von Ausgaben in Lebensmittel, Verkehr und Wohnen macht gemeinsame Merkmale sichtbar. Wenn die Verkäufe von Regenschirmen bei vorhergesagtem Regen wiederholt steigen, kann ein Geschäft den Trend nutzen, um seine Vorräte zu planen. Ein Trend ist ein Beleg, den es zu prüfen gilt; sein Grund ist wichtig für die Entscheidung, ob er anhalten wird.

Das vorgeschlagene Muster prüfen

Die Zahlen 1, 2, 4 bestimmen die nächste Zahl nicht eindeutig. Verdoppeln ergibt 8. Erhöht man die Abstände jeweils um eins, ergibt sich 7, denn die bisherigen Abstände sind 1 und 2. Um zu entscheiden, welches Muster zum Problem passt, sind weitere Fälle oder eine Regel nötig, die die Folge erklärt.

Suche nach bedeutsamen Unterschieden, bevor du eine Lösung wiederverwendest. Sowohl beim gleichmäßigen Aufteilen einer Rechnung als auch beim Aufteilen danach, was jede Person bestellt hat, gibt es eine gemeinsame Gesamtsumme. Gleichmäßiges Aufteilen löst die erste Aufgabe, aber für die zweite wird die Bestellung jeder Person benötigt. Verwende die gemeinsame Struktur erst wieder, nachdem du das Detail erkannt hast, das das geforderte Ergebnis verändert.

Ein Modell kann einfacher als die Wirklichkeit und dennoch nützlich sein. Abstraktion behält die für einen bestimmten Zweck nötigen Informationen und lässt andere Details weg. Ihre Qualität hängt davon ab, ob sie die Fragen der Aufgabe beantworten kann.

Ein Modell für die Aufgabe auswählen

Ein U-Bahn-Plan zeigt Stationen, ihre Reihenfolge entlang jeder Linie und die Stellen, an denen sich Linien verbinden. Diese Details helfen Reisenden bei der Planung einer Fahrt. Der Plan kann Entfernungen verzerren und Straßenverläufe auslassen, weil sein Hauptzweck darin besteht, Verbindungen zu zeigen.

Derselbe Plan ist ein schlechtes Werkzeug, um zu bestimmen, wie weit der Fußweg zwischen zwei Stationen ist. Das Modell hat ein Detail weggelassen, das der neue Zweck benötigt. Ein Detail ist aufgrund des Problems relevant, nicht weil es allgemein interessant ist.

Betrachte zwei Modelle desselben Autos:

Das Rennspiel muss Bewegungen aktualisieren. Das Parkhaus muss das Auto identifizieren und seinen Aufenthalt verfolgen. Keines der Modelle muss jedes physische Merkmal des Autos erhalten.

Schritte hinter einem klaren Namen verbergen

Abstraktion ermöglicht es dir auch zu nutzen, was eine Komponente tut, ohne jedes Mal zu durchdenken, wie sie funktioniert. Wenn du ein Waschmaschinenprogramm auswählst, musst du den Motor nicht direkt steuern.

In einem Algorithmus ist eine Prozedur eine benannte Gruppe von Schritten. Der Aufruf des Namens führt diese Schritte aus. Ein Name wie average(list) vermittelt eine Aufgabe und verbirgt zugleich die wiederholte Rechnung. Eine Prozedur, die ein Ergebnis an die aufrufende Stelle zurücksendet, hat einen Rückgabewert. Die aufrufende Stelle kann diesen Wert speichern oder in einer anderen Berechnung verwenden.

Ein Parameter gibt einer Prozedur eine veränderliche Eingabe. drawPolygon(sides, length) hat zwei Parameter. Der Aufruf drawPolygon(6, 100) übergibt sechs Seiten und eine Länge von 100 Schritten. Das verbindet Abstraktion, die die Zeichenschritte verbirgt, mit Verallgemeinerung, die verschiedene Formen und Größen ermöglicht.

Die Abgrenzung einer Prozedur muss klar sein: Welche Eingaben nimmt sie an und welches Ergebnis oder welche Aktion erzeugt sie? Bei einem Mittelwert benötigt eine leere Liste eine besondere Behandlung, weil es keine Anzahl gibt, durch die dividiert werden kann. Das Verbergen von Schritten macht es nicht überflüssig, brauchbare Eingaben festzulegen.

Verständnisebenen aufbauen

Eine Chat-App bietet eine Möglichkeit, eine Nachricht zu senden. Darunter bietet das Betriebssystem Dienste an, die die App nutzen kann. Darunter führt die Hardware Operationen aus. Jede Schicht baut auf dem Verhalten der nächsten Schicht auf, ohne den Nutzenden der oberen Schicht jedes interne Detail der unteren offenzulegen. Eine interne Änderung kann auf die Schicht begrenzt bleiben, solange das zugesicherte Verhalten gleich bleibt.

Die Techniken unterstützen einander. Die Problemzerlegung bestimmt die Teile. Die Mustererkennung findet Teile mit einer gemeinsamen Struktur. Die Abstraktion gibt diesen Teilen Namen und klare Abgrenzungen, sodass sie kombiniert werden können.

Ein häufiger Abstraktionsfehler ist, eine Tatsache wegzulassen, die darüber entscheidet, ob ein Ergebnis funktioniert. Ein Routenplaner, der Einbahnstraßen ignoriert, kann eine unmögliche Fahrt vorschlagen. Um ein Modell zu prüfen, liste die Entscheidungen auf, die es unterstützen muss, und vergewissere dich, dass die behaltenen Daten für jede davon ausreichen.

Ein Algorithmus ist eine endliche, geordnete Folge genauer Anweisungen zur Lösung eines Problems oder zur Erfüllung einer Aufgabe. Bei zulässiger Eingabe liefert er nach einer endlichen Anzahl von Schritten die geforderte Ausgabe. Ein Rezept, eine Montageanleitung und die schriftliche Division nutzen alle diese Idee.

Die Eigenschaften des Verfahrens prüfen

Ein nützlicher Algorithmus hat festgelegte Eingaben und Ausgaben. Jeder Schritt muss genau genug sein, um eine einzige Bedeutung zu haben, und so beschaffen sein, dass er ausgeführt werden kann. Die Schritte müssen enden und ihr Ergebnis muss für jede zulässige Eingabe korrekt sein.

„Finde die größte Zahl“ nennt ein Ziel, legt aber kein Verfahren fest. „Prüfe jede Zahl und merke dir die bisher größte“ gibt ein Verfahren vor, das zu Anweisungen ausgearbeitet werden kann. Es wirft auch eine Frage zur Eingabe auf: Was soll bei einer leeren Liste geschehen? Wenn du zulässige Eingaben festlegst, vermeidest du ein unvollständiges Verfahren.

Anweisungen im Alltag können Lücken lassen, die Menschen aus Erfahrung füllen. „Tu die Marmelade auf das Brot“ lässt das Öffnen des Glases und das Verstreichen einer Menge auf einer Oberfläche aus. Wenn du ein Verfahren für die automatische Ausführung entwirfst, gib die Aktionen an, die das ausführende System benötigt, und bringe sie in eine brauchbare Reihenfolge.

Das Verfahren von seiner Darstellung unterscheiden

Ein Algorithmus ist das Lösungsverfahren. Ein Programm drückt ein Verfahren in einer Programmiersprache aus, sodass ein Computer es ausführen kann. Derselbe Algorithmus kann in Pseudocode, in einem Programmablaufplan und in Programmen stehen, die in verschiedenen Sprachen geschrieben sind.

Drei Kontrollstrukturen ordnen die Ausführung:

Zusammen mit Variablen reichen diese Strukturen aus, um jeden Algorithmus auszudrücken. Das ist die Idee hinter einem klassischen Ergebnis, das Böhm und Jacopini 1966 veröffentlichten. Ein Algorithmus kann sie kombinieren: eine Liste durchlaufen, jeden Wert prüfen und ein gespeichertes Ergebnis der Reihe nach aktualisieren.

Korrekte Verfahren vergleichen

Angenommen, ein alphabetisch sortiertes Telefonbuch hat 1.000 Seiten. Das Prüfen einer Seite nach der anderen kann 1.000 Seitenprüfungen erfordern. Wenn du jeweils zwei Seiten umblätterst und nur jede zweite Seite prüfst, brauchst du bis zu etwa 500 Prüfungen und einen Schritt zurück, falls du den Namen überblättert hast.

Ein anderes Verfahren schlägt den verbleibenden Abschnitt in der Mitte auf und behält die Hälfte, die den Namen enthalten kann. Höchstens 10 Halbierungen reduzieren 1.000 mögliche Seiten auf eine:

1000 → 500 → 250 → 125 → 63 → 32
     → 16 → 8 → 4 → 2 → 1

Die sortierte Reihenfolge macht es möglich, eine Hälfte sicher zu verwerfen. Ohne diese Ordnung könnte die verworfene Hälfte den Namen enthalten. Diese Annahme über die Eingabe gehört zum Verfahren.

Bei 2.000 Seiten kann das Prüfen jeder Seite doppelt so viele Prüfungen erfordern, während die Halbierung nur eine weitere Halbierung benötigt: 11. Der Vergleich, wie die Schrittzahl wächst, erklärt mehr als die Zeitmessung eines einzelnen Durchlaufs auf einer einzelnen Maschine.

Prüfe die Korrektheit, bevor du die Geschwindigkeit lobst. Ein Verfahren, das nur die erste und die letzte Zahl einer Liste untersucht, findet in [7, 3, 12] zufällig die 12. In [7, 12, 3] übersieht es die 12. Ein erfolgreiches Beispiel kann nicht belegen, dass das Verfahren den gesamten Eingabebereich bewältigt.

Pseudocode beschreibt einen Algorithmus durch strukturierte, lesbare Anweisungen. Er ist nicht an eine einzelne Programmiersprache gebunden. Du kannst damit an der Logik arbeiten, bevor du dich mit den Satzzeichen und anderen Schreibregeln einer Sprache befasst.

Die Schreibweise lesen

Schlüsselwörter stehen in Großbuchstaben: INPUT, OUTPUT, IF, WHILE und FOR. Jede Anweisung steht in einer eigenen Zeile. Einrückungen zeigen, welche Anweisungen zu einem Block gehören. Ein Kommentar beginnt mit // und erklärt den Code, ohne eine Aktion hinzuzufügen.

Der Pfeil ← bedeutet Zuweisung. Manche andere Pseudocode-Schreibweisen verwenden = oder SET … TO für Zuweisungen. Hier vergleicht = Werte. Lies count ← 0 als „count erhält null“. Eine Variable ist ein benannter Platz, der einen veränderlichen Wert speichert. Eine Konstante hat einen Namen, behält aber denselben Wert, etwa PASS_MARK ← 50.

Die rechte Seite einer Zuweisung wird zuerst ausgewertet. Ihr Ergebnis ersetzt den alten Wert auf der linken Seite. Enthält count den Wert 4, liest count ← count + 1 die alte 4, addiert 1 und speichert 5. Es ist eine Anweisung, gespeicherte Daten zu ändern, keine Gleichung, die behauptet, eine Zahl sei gleich sich selbst plus eins.

Datentypen und Operationen zuordnen

Die Addition der Zahlen 12 und 3 ergibt 15. Das Verketten der Zeichenketten „12“ und „3“ ergibt „123“. Wähle beschreibende Namen wie temperature und total, damit die Rolle eines Werts sichtbar bleibt.

Zu den arithmetischen Operatoren gehören +, −, * und /. DIV liefert den ganzzahligen Quotienten, MOD den Rest. Somit ist 17 DIV 5 gleich 3 und 17 MOD 5 gleich 2. Die Prüfung n MOD 2 = 0 erkennt eine gerade ganze Zahl. Vergleiche wie =, ≠, <, >, ≤ und ≥ liefern Wahrheitswerte.

Einlesen, berechnen und anzeigen

INPUT minutes
hours ← minutes DIV 60
rest ← minutes MOD 60
OUTPUT hours, "h", rest, "min"

Bei 135 Minuten ergeben zwei vollständige Gruppen zu je 60 insgesamt 120 Minuten, sodass 15 übrig bleiben. Die Ausgabe lautet „2 h 15 min“. INPUT empfängt Daten, die beiden Zuweisungen verarbeiten sie und OUTPUT sendet das Ergebnis.

Einen Wert vor dem Ersetzen erhalten

Angenommen, a enthält 5 und b enthält 8. Die Anweisungen a ← b und anschließend b ← a führen dazu, dass beide Variablen 8 enthalten. Die erste Anweisung hat die einzige gespeicherte Kopie von 5 überschrieben.

Verwende eine Hilfsvariable:

temp ← a
a ← b
b ← temp

Nach der ersten Zeile enthält temp den Wert 5. Die zweite Zeile schreibt 8 in a. Die dritte schreibt die gespeicherte 5 in b. Eine Zuweisung kopiert einen aktuellen Wert; sie erzeugt keine dauerhafte Verbindung zwischen Variablen.

Gib jeder Variablen einen Anfangswert, bevor du sie ausliest. Eine laufende Summe benötigt total ← 0 vor ihrer ersten Addition. Steht die Zuweisung nach der Addition, hat der erste Schritt keinen festgelegten Anfangswert.

Verzweigung wählt aus, welche Anweisungen ausgeführt werden. Eine Bedingung ist ein Ausdruck mit dem Wert TRUE oder FALSE. Der Vergleich score ≥ 50 fragt, ob die aktuelle Punktzahl mindestens 50 beträgt.

IF und ELSE verwenden

IF score ≥ 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
END IF

Genau ein Zweig wird ausgeführt. Bei 50 ist die Bedingung wahr und die Ausgabe lautet „Pass“. Bei 49 ist sie falsch und die Ausgabe lautet „Fail“. Ein IF ohne ELSE überspringt seinen Block einfach, wenn seine Bedingung falsch ist.

Der Vergleich muss zur Regel passen. „Mindestens 50“ schließt 50 ein und benötigt daher ≥. Mit > würde diese Punktzahl am Grenzwert abgelehnt. Werte am Schwellenwert zu testen ist eine direkte Möglichkeit, diesen Fehler zu finden.

Mehrere Fälle ordnen

Eine ELSE IF-Kette prüft Bedingungen der Reihe nach und führt den ersten zutreffenden Zweig aus:

IF temperature ≥ 30 THEN
    OUTPUT "Hot"
ELSE IF temperature ≥ 20 THEN
    OUTPUT "Warm"
ELSE IF temperature ≥ 10 THEN
    OUTPUT "Mild"
ELSE
    OUTPUT "Cold"
END IF

Für 24 °C ist die erste Prüfung falsch und die zweite wahr. Die Ausgabe lautet „Warm“. Für 10 °C wird der dritte Zweig ausgeführt. Für −3 °C wird das abschließende ELSE ausgeführt.

Eine Temperatur von 35 °C erfüllt alle drei aufgeschriebenen Vergleiche, aber nur der erste zutreffende Zweig wird ausgeführt. Stünde temperature ≥ 10 zuerst, würde dieser Vergleich bei 35 zutreffen und „Mild“ ausgeben. Prüfe bei überlappenden Schwellenwerten der Form „mindestens“ zuerst den größten. Die unteren Zweige behandeln dann Werte, die die höheren Schwellenwerte nicht erfüllen.

Bedingungen verknüpfen

Um Temperaturen von 10 °C bis ausschließlich 20 °C einzuschließen, verwende temperature ≥ 10 AND temperature < 20. Beide Schranken müssen eingehalten werden. Bei 15 sind beide Bedingungen wahr. Bei 20 ist die zweite falsch.

Mit OR für diesen Bereich ergibt sich temperature ≥ 10 OR temperature < 20. Das akzeptiert jede Zahl: Ein Wert unter 10 erfüllt immer noch den zweiten Teil, während jeder Wert ab 10 den ersten erfüllt. OR ist nützlich, wenn eine der beiden Möglichkeiten genügt, nicht wenn beide Schranken eingehalten werden müssen.

Eine Entscheidung in eine andere setzen

Ein verschachteltes IF setzt eine Entscheidung in einen Zweig einer anderen. Du könntest zuerst prüfen, ob ein Passwort lang genug ist, und dann innerhalb des erfolgreichen Zweigs prüfen, ob es eine Ziffer enthält. Die innere Entscheidung wird nur erreicht, wenn die äußere Bedingung es zulässt.

Rücke den inneren Block ein, damit die Wege sichtbar sind. Wenn mehrere verschachtelte Entscheidungen eine einfache Regel schwer lesbar machen, erwäge, Bedingungen mit AND zu verknüpfen oder eine ELSE IF-Kette zu verwenden. Verfolge einen Wert durch die tatsächliche Reihenfolge, bevor du annimmst, dass jede aufgeschriebene Prüfung erreicht wird.

Iteration wiederholt einen Block von Anweisungen. Eine Schleife lässt dich wiederholte Arbeit einmal ausdrücken. Du musst aber weiterhin entscheiden, wann sie beginnt, wann sie endet und welche Werte sich bei jedem Durchlauf ändern.

Die Steuerung der Wiederholung wählen

Eine FOR-Schleife eignet sich bei bekannter Anzahl von Wiederholungen. Eine bedingungsgesteuerte Schleife eignet sich für eine Aufgabe, deren Endpunkt von Werten oder neuen Eingaben abhängt. Der Rumpf einer WHILE-Schleife wird unter Umständen kein einziges Mal ausgeführt. Der Rumpf einer fußgesteuerten REPEAT … UNTIL-Schleife wird mindestens einmal ausgeführt.

Einen Countdown nachvollziehen

n ← 3
WHILE n > 0 DO
    OUTPUT n
    n ← n − 1
END WHILE
OUTPUT "Go!"

Bei der ersten Prüfung ist n gleich 3. Die Schleife gibt 3 aus und ändert n auf 2. Die nächsten Durchläufe geben 2 und 1 aus. Nach der Aktualisierung von 1 auf 0 ist die Prüfung falsch. Der Ablauf verlässt die Schleife und gibt „Go!“ aus.

Ohne die Aktualisierung bleibt n gleich 3, sodass die Schleife ihren Abbruchzustand nie erreicht. Eine Schleife, die enden soll, braucht eine Möglichkeit, die Bedingung zu ändern: eine Aktualisierung innerhalb der Schleife oder eine neue Eingabe.

Eine Summe bilden und Elemente zählen

Eine Akkumulatorvariable baut über mehrere Durchläufe ein Ergebnis auf. Eine Zählvariable hält fest, wie oft etwas auftritt. Um den Mittelwert der Tagestemperaturen 18, 21, 19, 22 und 20 °C zu finden:

total ← 0
count ← 0
FOR EACH t IN temperatures
    total ← total + t
    count ← count + 1
END FOR
OUTPUT total / count

Die aufeinanderfolgenden Summen sind 18, 39, 58, 80 und 100. Die Zählvariable steht am Ende auf 5, also beträgt der Mittelwert 20 °C. Initialisiere beide Variablen vor der Schleife. Würdest du total innerhalb der Schleife zurücksetzen, gingen die vorherigen Additionen verloren. Eine leere Liste benötigt vor der Division eine gesonderte Prüfung, weil ihre Anzahl null ist.

Den bisher besten Wert merken

Setze largest bei einer nicht leeren Liste auf das erste Element. Prüfe dann jeden Wert und ersetze largest, sobald ein größerer Wert erscheint:

largest ← first item of list
FOR EACH value IN list
    IF value > largest THEN
        largest ← value
    END IF
END FOR
OUTPUT largest

Für [7, 3, 12, 5] bleibt der gemerkte beste Wert zunächst 7, wird zu 12 und bleibt bei 12. Ein Startwert von null scheitert bei einer Liste wie [−4, −9, −2], deren größter Wert −2 ist. Null war kein Kandidat.

Den ersten und den letzten Durchlauf prüfen

Ein Off-by-one-Fehler fügt eine Wiederholung hinzu oder lässt eine aus. FOR i ← 0 TO 5 wird sechsmal ausgeführt. Im Countdown würde n ≥ 0 auch null ausgeben. Schreibe den ersten und den letzten Wert der Steuervariablen auf, um die Anzahl zu prüfen.

Verschachtelte Schleifen wiederholen eine Schleife innerhalb einer anderen. Bei 3 Zeilen und 4 Spalten wird der innere Block für jede Zeile viermal ausgeführt, insgesamt also 12-mal. Die innere Schleife beginnt bei jedem äußeren Durchlauf erneut.

Ein Programmablaufplan stellt einen Algorithmus als Formen dar, die durch Pfeile verbunden sind. Die Formen kennzeichnen die Arten von Schritten und die Pfeile zeigen, welcher Schritt als Nächstes ausgeführt wird. Ein kurzer Plan macht einen Ablauf für Menschen sichtbar, die möglicherweise keinen Code lesen.

Für jede Aufgabe eine Form wählen

Die wichtigsten Symbole folgen ISO 5807. Sie haben unterschiedliche Aufgaben:

Eine Ablauflinie hat einen Pfeil, der die Richtung zeigt. Die übliche Leserichtung ist von oben nach unten und von links nach rechts, aber der Pfeil bestimmt den tatsächlichen nächsten Schritt. Eine Linie, die zu einem früheren Punkt zurückführt, kann eine Wiederholung zeigen.

Eine einfache Sequenz erstellen

Um die Fläche eines rechteckigen Raums zu berechnen, verwende diese fünf Symbole in der angegebenen Reihenfolge:

1. Grenzstelle: „Start“.
2. Ein-/Ausgabe: „Länge, Breite eingeben“.
3. Verarbeitung: area ← length * width.
4. Ein-/Ausgabe: „Fläche ausgeben“.
5. Grenzstelle: „Ende“.

Verbinde jeden Schritt durch einen Pfeil mit dem nächsten. Bei einer Länge von 4,5 m und einer Breite von 3 m ergibt die Berechnung 13,5 Quadratmeter. Das Einlesen der Eingabe berechnet nicht die Fläche; das gehört in ein eigenes Verarbeitungsrechteck. Die Anzeige der Fläche gehört in das Ausgabeparallelogramm.

Dieser Plan hat weder eine Auswahl noch einen wiederholten Weg. Er ist eine reine Sequenz und seine Form macht die Reihenfolge deutlich.

Einer Entscheidung mit aktuellen Werten folgen

Eine Raute stellt eine Frage oder prüft einen Wert. Beschrifte bei einer Ja-Nein-Frage wie score ≥ 50? die Ausgänge mit „Ja“ und „Nein“. Werte die Bedingung mit der aktuellen Punktzahl aus und folge genau einem passenden Pfeil.

Eine Verzweigung kann mehr als zwei mögliche Ausgänge haben, wenn sie mehrere unterschiedliche Werte prüft. Beschrifte jeden Ausgang mit dem Wert oder Fall, für den er steht. Die Beschriftungen sollen den nächsten Schritt eindeutig machen.

Eine Aktion wie count ← count + 1 gehört in ein Verarbeitungsrechteck. Eine Frage wie count < 5? gehört in eine Verzweigungsraute. Wenn du diese Aufgaben vermischst, ist nicht mehr erkennbar, ob ein Wert geändert oder geprüft wird.

Die Verbindungen prüfen

Ein übersichtlicher Plan hat einen Start und mindestens ein Ende. Jedes Verarbeitungs- und Ein-/Ausgabesymbol hat eine abgehende Ablauflinie. Jede Ja-Nein-Entscheidung hat zwei beschriftete Ausgänge. Folge jedem Weg und prüfe, ob er einen vorgesehenen nächsten Schritt oder Ende erreicht.

Lass einen Zweig nach seiner Ausgabe nicht offen enden. Sollen beide Zweige mit demselben Schritt fortfahren, zeichne sie vor diesem Schritt zusammen. Verwende beschriftete Verbindungsstellen, wenn lange oder sich kreuzende Linien die Seite unübersichtlich machen würden. Ein Unterprogrammsymbol ermöglicht es, eine große Prozedur in einem eigenen Plan darzustellen, während der Hauptplan seine Gesamtstruktur behält.

Pseudocode und Programmablaufpläne können denselben Algorithmus ausdrücken. Bei der Umwandlung zwischen ihnen müssen die Reihenfolge der Aktionen, die Bedingungen und jeder Weg durch den Ablauf erhalten bleiben. Ein übersichtliches Diagramm mit einer anders platzierten Prüfung beschreibt einen anderen Algorithmus.

Eine Auswahl zeigen und die Wege wieder zusammenführen

Zeichne für eine Bestehensgrenze von 50 eine Raute mit der Beschriftung score ≥ 50?. Ihr Ja-Ausgang führt zu einem Ausgabeparallelogramm mit der Beschriftung „Pass“. Ihr Nein-Ausgang führt zu einem mit der Beschriftung „Fail“. Führe die Wege vor Ende zusammen.

Im Pseudocode werden diese Wege zu den Zweigen IF und ELSE. Der Punkt, an dem sie wieder zusammenlaufen, entspricht der ersten Anweisung nach END IF. Der Plan darf die Ausgabe „Pass“ nicht zur Ausgabe „Fail“ weiterleiten; bei einem einzelnen Durchlauf gehört nur eine der beiden Ausgaben zum Weg.

Die Prüfung an die richtige Stelle setzen

Eine Schleife hat einen Weg zurück zu einem früheren Schritt und eine Entscheidung, die steuert, ob die Wiederholung fortgesetzt wird. Setze bei einer WHILE-Schleife die Entscheidung vor den Rumpf. Der Ausgang für eine falsche Bedingung führt am Rumpf vorbei, sodass kein einziger Durchlauf möglich ist.

Setze bei einem fußgesteuerten REPEAT … UNTIL die Entscheidung nach den Rumpf. Der Ausgang für eine falsche Bedingung führt zum Rumpf zurück, der für eine wahre Bedingung verlässt die Schleife. Der Rumpf wird mindestens einmal ausgeführt, weil der Ablauf ihn vor der ersten Prüfung erreicht.

Eine Anmeldung mit drei Versuchen durchgehen

attempts ← 0
REPEAT
    INPUT password
    attempts ← attempts + 1
UNTIL password = storedPassword OR attempts = 3
IF password = storedPassword THEN
    OUTPUT "Welcome"
ELSE
    OUTPUT "Account locked"
END IF

Beginne den Plan mit Start und einem Verarbeitungsrechteck für attempts ← 0. Zeichne danach das Parallelogramm für die Passworteingabe und dann das Rechteck für die Erhöhung. Die Schleifenraute fragt: „Passwort korrekt ODER attempts = 3?“ Ihr Nein-Ausgang führt zurück zur Passworteingabe. Ihr Ja-Ausgang verlässt die Schleife.

Die Abbruchbedingung nennt zwei mögliche Gründe für das Ende und kann daher die abschließende Meldung nicht allein auswählen. Ergänze eine zweite Raute, die fragt, ob das Passwort korrekt ist. Ja führt zu „Welcome“; Nein führt zu „Account locked“. Bei einem korrekten dritten Versuch endet die Schleife und der Zweig für das korrekte Passwort begrüßt die Nutzerin oder den Nutzer trotzdem.

Durch Verfolgen der Wege umwandeln

Wandle beim Übergang von Pseudocode zu einem Plan jede Zuweisung in ein Rechteck und jede Eingabe oder Ausgabe in ein Parallelogramm um. Verwandle Verzweigungs- und Schleifenprüfungen in Rauten. Verbinde den Rumpf an der richtigen Stelle zurück mit seiner steuernden Entscheidung.

Untersuche beim Übergang von einem Plan zu Pseudocode, wohin die Wege jeder Raute führen. Wege, die Alternativen ausführen und wieder zusammenlaufen, deuten auf eine Verzweigung hin. Ein Weg, der zu früheren Schritten zurückführt, deutet auf eine Iteration hin. Rücke jeden Rumpf passend zu seiner Abgrenzung ein.

Prüfe das Ziel jedes Rückwärtspfeils. Eine Rückkehr nach der steuernden Entscheidung würde die nächste Prüfung überspringen. Eine Rückkehr vor eine einmalige Initialisierung könnte eine Zählvariable bei jedem Durchlauf zurücksetzen und das Ende der Schleife verhindern.

Ein Algorithmus kann vernünftig aussehen und dennoch das Falsche tun. Beim Nachvollziehen werden seine Anweisungen genau befolgt und die Ergebnisse festgehalten. Beim Testen wird er mit ausgewählten Eingaben ausgeführt und die Ergebnisse werden überprüft. Die Fehlersuche und Fehlerbehebung findet und behebt die Ursache eines Fehlers.

Den Zustand sichtbar machen

Eine Ablauftabelle hält Variablen und Ausgaben während eines Schreibtischtests fest. Verwende die aktuellen Werte, nicht die Werte, die du als Absicht der Urheberin oder des Urhebers vermutest. Zum Beispiel:

total ← 0
FOR i ← 1 TO 4
    total ← total + i
END FOR
OUTPUT total

Diese kompakte Tabelle zeigt den Zustand nach jeder Addition. Ergänze bei einem schwer zu findenden Fehler Zeilen nach einzelnen Anweisungen und eine Spalte für die Ergebnisse von Bedingungen. Auch eine falsche Schleifenbedingung gehört in einen detaillierten Nachvollzug: Sie erklärt, warum der Ablauf die Schleife verlässt.

Tests anhand der Regeln auswählen

Ermittle das erwartete Ergebnis, bevor du jeden Test ausführst. Andernfalls ist es leicht, die Ausgabe des Programms zu akzeptieren, nur weil sie erschienen ist. Manche Tests prüfen eine Eigenschaft, etwa die Reihenfolge der Ausgabe, statt eines einzelnen genauen Ergebnisses.

Für zulässige Punktzahlen von 0 bis 100 mit einer Bestehensgrenze von 50:

Grenzdaten und ungültige Daten können sich überschneiden: −1 liegt sowohl nahe an einer Grenze als auch außerhalb des zulässigen Bereichs. Die Kategorie erklärt, warum der Test nützlich ist. Eine Regel mit score > 50 besteht normale Tests bei 73 und 49, scheitert aber bei genau 50.

Teste auch ungewöhnliche Eingabestrukturen. Eine leere Liste, ein einzelnes Element, lauter gleiche Werte und negative Werte decken unterschiedliche Annahmen auf. Ein Algorithmus für den Mittelwert muss eine leere Liste behandeln, bevor er durch ihre Anzahl dividiert. Ein Algorithmus für den größten Wert, der mit null initialisiert wird, kann bei einer Liste mit ausschließlich negativen Werten scheitern.

Den zu behebenden Fehler bestimmen

Ein Syntaxfehler verstößt gegen die Schreibregeln einer Sprache, etwa eine fehlende schließende Klammer. Ein Laufzeitfehler tritt während der Ausführung auf, etwa eine Division durch null. Ein logischer Fehler lässt die Ausführung zu, liefert aber ein falsches Ergebnis, etwa wenn die zum Bestehen ausreichende Punktzahl am Grenzwert durch > ausgeschlossen wird.

Diese Kategorien helfen dir, eine Prüfung auszuwählen. Die Syntaxprüfung erkennt fehlerhafte Sprachformen. Ein Nachvollzug kann bei einem logischen Fehler den ersten falschen Zustand aufdecken. Testdaten können einen Laufzeitfehler auslösen, der bei einer typischen Eingabe nie auftritt.

Vom ersten abweichenden Wert aus Fehler beheben

Reproduziere den Fehler mit einer bestimmten Eingabe. Verfolge Zwischenwerte nach oder zeige sie an und finde den ersten Schritt, bei dem der tatsächliche Zustand vom erwarteten abweicht. Ändere die Ursache und führe dann den fehlgeschlagenen Test und die früheren Tests erneut aus. Eine Korrektur in einem Zweig kann einen anderen beeinträchtigen.

Bestandene ausgewählte Tests liefern Belege für diese Eingaben. Korrektheit verlangt weiterhin, dass das Verfahren jede zulässige Eingabe bewältigt. Verbinde daher das Testen mit Überlegungen zu den Anweisungen und ihren Annahmen.

Bei der blockbasierten Programmierung stehen grafische Blöcke für Anweisungen und Werte. Du ziehst sie in einen Arbeitsbereich und steckst sie zusammen. Die Formen nehmen dir einen großen Teil der Arbeit ab, dir die Syntax zu merken, sodass du dich auf die Logik des Programms konzentrieren kannst.

Die Teile eines Projekts kennen

Scratch wurde am MIT Media Lab entwickelt. Zu den anderen blockbasierten Umgebungen gehören Snap!, entwickelt an der University of California, Berkeley, Microsoft MakeCode und Blockly. Blockly ist eine Bibliothek zum Erstellen von Blockoberflächen; sie entstand bei Google und wechselte 2025 zur Raspberry Pi Foundation.

In Scratch ist die Bühne der Bereich, in dem das Projekt sichtbar abläuft. Figuren sind Charaktere oder Objekte, die darauf handeln. Eine Figur kann Skripte, Kostüme und Klänge haben. Ein Skript ist ein Stapel von Blöcken; ein Kostüm ist ein Bild, das die Figur anzeigen kann.

Die Bühne ist 480 mal 360 Scratch-Einheiten groß. Ihre Mitte ist der Koordinatenpunkt (0|0). Die waagerechten x-Koordinaten reichen von −240 bis 240 und die senkrechten y-Koordinaten von −180 bis 180. Bewegungsschritte in Scratch sind Bühneneinheiten, keine Meter.

Dich von der Blockform leiten lassen

Ein Werteblock passt in ein Eingabefeld eines anderen Blocks. Ein Befehl passt in einen Stapel von Aktionen. Ein Wahrheitsblock passt in ein Bedingungsfeld. Die Form hilft, die Abgabe eines Werts von der Ausführung eines Befehls zu unterscheiden.

Blöcke nach Kategorien finden

Scratch 3 hat neun farblich gekennzeichnete Hauptkategorien: Bewegung, Aussehen, Klang, Ereignisse, Steuerung, Fühlen, Operatoren, Variablen und Meine Blöcke. Bewegung ändert die Position; Aussehen steuert das sichtbare Erscheinungsbild und das Sprechen; Fühlen empfängt Informationen; Operatoren berechnen oder vergleichen. Die Erweiterung Malstift wird gesondert hinzugefügt, wenn ein Projekt beim Bewegen einer Figur Linien zeichnen soll.

Eine kurze Sequenz ausführen

Wähle eine Figur und setze diese Blöcke unter einen Kopfblock „Wenn die grüne Flagge angeklickt wird“:

1. „gehe zu x: 0 y: 0“
2. „sage Hallo! für 2 Sekunden“
3. „gehe 100 er-Schritt“

Klicke auf die grüne Flagge. Die Figur geht zuerst in die Mitte, zeigt dann zwei Sekunden lang „Hallo!“ an und bewegt sich anschließend 100 Schritte in ihre aktuelle Richtung. Der zeitlich begrenzte Sprechblock macht die Pause sichtbar. Der Stapel wird von oben nach unten ausgeführt.

Ein loser Stapel kann durch direktes Anklicken im Arbeitsbereich ausgeführt werden. Er startet aber nicht durch die grüne Flagge, wenn ihm der passende Ereignis-Kopfblock fehlt. Prüfe sowohl die Reihenfolge des Stapels als auch sein Startereignis, wenn das Projekt nicht zu reagieren scheint.

Auch korrekt zusammenpassende Blöcke brauchen einen korrekten Plan. Eine Bewegung kann vor dem vorgesehenen Zurücksetzen der Position stattfinden oder eine Frage erst nach der Anzeige des Ergebnisses gestellt werden. Die Formen helfen beim zulässigen Zusammenbau; das Nachvollziehen zeigt, ob dieser Aufbau die beabsichtigte Arbeit erledigt.

Scratch nutzt dieselben Ideen wie Pseudocode: einen Wert speichern, eine Bedingung prüfen und Schritte wiederholen. Die Blöcke machen die Struktur sichtbar, aber ihre Position bestimmt weiterhin, wann jede Aktion geschieht.

Eine zur Aufgabe passende Schleife wählen

„wiederhole 10 mal“ führt seinen Rumpf zehnmal aus. „wiederhole fortlaufend“ läuft weiter, bis das Programm stoppt, und eignet sich für ein Spiel, das ständig Eingaben prüft. „wiederhole bis “ prüft vor jedem Durchlauf und endet, wenn die Bedingung wahr ist. Anders als das fußgesteuerte REPEAT … UNTIL im Pseudocode kann dieser Block daher kein einziges Mal ausgeführt werden.

Mit der Erweiterung Malstift und abgesenktem Stift zeichnet „wiederhole 4 mal“ mit den enthaltenen Blöcken „gehe 100 er-Schritt“ und „drehe dich um 90 Grad nach rechts“ ein Quadrat. Verwende für ein regelmäßiges Sechseck sechs Wiederholungen und eine Drehung um 60 Grad. Die Richtungsänderungen addieren sich um die Figur herum zu 360 Grad.

Einen Wert speichern und einen Zweig wählen

Erstelle score unter Variablen. „setze score auf 0“ weist den Anfangswert zu. „ändere score um 1“ addiert zum aktuellen Wert. Setze das Zurücksetzen vor eine Schleife zur Punktevergabe; innerhalb der Schleife würde es jedes Mal den bisherigen Punktestand löschen.

Der abgerundete Werteblock score liefert den aktuellen Wert an andere Blöcke. Wenn du sein Kästchen aktivierst, wird auf der Bühne eine Anzeige eingeblendet, die beim Nachvollziehen hilft.

Ein „falls … dann … sonst“-Block führt einen seiner beiden Rümpfe aus. Sein sechseckiges Bedingungsfeld nimmt einen Wahrheitsblock wie „(score) > (9)“ oder „wird Mauszeiger berührt?“ auf. Die Operatoren „und“, „oder“ und „nicht“ verknüpfen Bedingungen mit derselben Bedeutung wie im Pseudocode.

Eingabe empfangen, Text erstellen und anzeigen

Der Block „frage [Wie heißt du?] und warte“ hält für eine Eingabe an und speichert sie in „Antwort“. Der Block „verbinde [Hallo, ] (Antwort)“ erstellt Text. Setze diesen Werteblock in „sage … für 2 Sekunden“, um die Begrüßung anzuzeigen. Bei der Eingabe „Amara“ lautet die Ausgabe „Hallo, Amara“.

Die drei Aufgaben sind getrennt: Fragen empfängt Daten, Verbinden verarbeitet Text und Sagen zeigt ihn an. Ein Werteblock kann einen nützlichen Wert berechnen, ohne selbst etwas anzuzeigen.

Ein Ratespiel erstellen

Verwende diese Blockreihenfolge; jeder eingerückte Teil steht innerhalb des umschließenden Blocks:

"when green flag clicked"
"set secret to (pick random 1 to 10)"
"ask [Guess a number from 1 to 10] and wait"
"repeat until <(answer) = (secret)>"
    "if <(answer) > (secret)> then"
        "say [Too high] for 2 seconds"
    "else"
        "say [Too low] for 2 seconds"
    "ask [Guess a number from 1 to 10] and wait"
"say [Correct!] for 2 seconds"

Ein richtiger erster Tipp überspringt die Schleife. Bei der Geheimzahl 6 und den Tipps 3, 8 und 6 lautet die Rückmeldung „Too low“, „Too high“ und dann „Correct!“. Die erneute Frage innerhalb der Schleife liefert einen Wert, der ihre Bedingung wahr machen kann.

Zeitlich begrenzte Rückmeldungen sind wichtig. Die Frage einer sichtbaren Figur nutzt deren Sprechblase, sodass die nächste Frage eine unbegrenzte Sprechblase sofort ersetzt. Ein zwei Sekunden lang angezeigter Text lässt die lernende Person zuerst die Rückmeldung lesen.

Lies die Schleife als WHILE answer ≠ secret, um sie in Pseudocode zu prüfen. Ohne die wiederholte Frage bleibt das Spiel bei der alten falschen Antwort gefangen; verschiebst du die abschließende Erfolgsmeldung in die Schleife, steht sie auf dem falschen Weg.

Ein Scratch-Projekt hat oft mehrere Skripte, die auf unterschiedliche Ereignisse warten. Ereignisgesteuerte Programmierung startet ein Skript, wenn ein Ereignis eintritt. Ein eigener Block ermöglicht es einem Skript, eine benannte, wiederverwendbare Aufgabe aufzurufen.

Das richtige Skript starten

Zu den Kopfblöcken gehören „Wenn die grüne Flagge angeklickt wird“, „Wenn diese Figur angeklickt wird“, „Wenn Taste Leertaste gedrückt wird“ und „Wenn ich [Nachricht] empfange“. Jeder beschreibt, was den angehängten Stapel startet.

Mehrere Skripte können auf dasselbe Ereignis reagieren. Zwei Figuren können beide starten, wenn die grüne Flagge angeklickt wird, und dann nebeneinander laufen. Die Position ihrer Stapel im Arbeitsbereich legt keine Ausführungsreihenfolge zwischen ihnen fest.

Innerhalb eines Skripts bleiben Aktionen von oben nach unten geordnet. Zwischen Skripten kann der zeitliche Ablauf wichtig sein. Bewegen zwei Skripte dieselbe Figur in entgegengesetzte Richtungen, hängt ihr gemeinsames Ergebnis davon ab, wann ihre Aktionen ausgeführt werden. Gib Skripten klare Aufgaben und koordiniere die Arbeit, wenn eine Aufgabe das Ergebnis einer anderen benötigt.

Eine Nachricht zwischen Skripten senden

„sende [Spiel vorbei] an alle“ sendet eine Nachricht an alle Figuren und die Bühne. Passende Skripte mit „Wenn ich [Spiel vorbei] empfange“ starten als Reaktion. Der Nachrichtenname muss übereinstimmen; er bezeichnet das Ereignis, das die Empfänger behandeln.

„sende an alle und warte“ hält auch das sendende Skript an, bis die empfangenden Skripte beendet sind. Nutze dies, wenn die nächste Aktion von ihrem Abschluss abhängt. Ein steuerndes Skript kann zum Beispiel eine Einrichtungsnachricht senden und warten, während Figuren zu ihren Startpositionen gehen, und dann das Spiel beginnen.

Das Warten legt keine Reihenfolge zwischen den Empfängern fest. Wenn zwei empfangende Einrichtungsskripte denselben Wert überschreiben, benötigen sie weiterhin einen Plan, der widersprüchliche Zuständigkeiten vermeidet. Ein Empfangsskript, das endlos läuft, verhindert ebenfalls, dass das wartende sendende Skript fortfährt.

Wiederholter Arbeit einen Namen und eine Eingabe geben

Erstelle unter Meine Blöcke einen eigenen Block mit einer Eingabe namens size. Seine Definition lässt sich so beschreiben:

"define square (size)"
    "repeat 4"
        "move (size) steps"
        "turn right 90 degrees"

Bei abgesenktem Stift zeichnet der Aufruf „square (100)“ Seiten von 100 Schritten. Der Aufruf „square (60)“ nutzt dieselben Anweisungen mit kürzeren Seiten. Der eigene Block bietet Abstraktion, indem er die Schritte hinter einem Namen verbirgt, und Verallgemeinerung, indem die aufrufende Stelle die Größe übergeben kann.

Der Aufruf führt die Definition aus; er kopiert keine zweite, von Hand gepflegte Version in das Skript. Eine Änderung der Definition ändert die Arbeit, die spätere Aufrufe ausführen. So lässt sich ein wiederholtes Verfahren leichter pflegen.

Die Ideen in Text übertragen

In einer textbasierten Sprache tippst du die Anweisungen und befolgst die Regeln der Sprache für Satzzeichen und Abstände. Die zugrunde liegenden Überlegungen zu Zustand, Bedingungen und Wiederholung gelten weiterhin.

Blöcke beseitigen viele Syntaxfehler, aber die falsche Bedingung kann weiterhin den falschen Weg wählen. Nachvollzüge und Tests bleiben nützlich. Große Blockprojekte können außerdem schwer zu überblicken und zu vergleichen sein, weil ihre Skripte viel Bildschirmplatz beanspruchen; Text lässt sich bei großen Softwareprojekten leichter durchsuchen und verwalten.