Einführung in die Programmierumgebung Lazarus Objektorientiertes Pascal

Transkript

1 Einführung in die Programmierumgebung Lazarus Objektorientiertes Pascal Michael Thielke 14. März

2 Inhaltsverzeichnis 1 Programmierung Digitaluhr - Einführung in Lazarus Ampelsimulation - Programmstruktur in Lazarus Programmiersprachen - Syntax und Semantik

3 1 Programmierung Die Erzeugung eines eigenen lauffähigen Programms ist immer ein komplexer Vorgang, bei dem viele Aspekte zu beachten sind. Wir werden versuchen, anhand einfacher Projekte zunächst möglichst einzelne Aspekte kennen zu lernen und zu verstehen. Grundsätzlich ist die Lösung eines Programmierproblems unabhängig von der verwendeten Programmiersprache. Der Algorithmus und die benötigten Variablen können frei formuliert und festgelegt werden. Erst danach wird die Lösung umgesetzt in ein fertiges Programm und erst dabei wird die Sprache selbst wichtig. Dennoch benötigen wir natürlich Grundkenntnisse einer Programmiersprache, d.h. wir müssen die Struktur der Programmentwicklungsumgebung, den Wortschatz der Sprache und ihre Syntax kennen lernen. 1.1 Digitaluhr - Einführung in Lazarus Wir werden mit der Programmentwicklungsumgebung LAZARUS arbeiten. Dieses System basiert auf der Sprache Turbopascal. Zum Einstieg wollen wir eine einfache Ampelsimulation entwickeln. Dabei können wir gut die einzelnen Kompenenten der Entwicklungsumgebung erforschen und erste Bausteine der Sprache lernen. Nach dem Start des Programms erscheinen drei Fenster auf dem Bildschirm. Zum einen finden wir Abbildung 1: Hauptmenü am oberen Rand das Hauptmenü mit der gesamten Werkzeugleiste. Aus dieser Leiste werden wir später alle Objekte entnehmen, mit denen wir in unserem Programm arbeiten wollen. Außerdem finden wir dort die üblichen Optionen zum Öffnen, Speichern und Starten des laufenden Projekts. Als ersten Arbeitsschritt speichern wir unser Projekt. Dabei ist es wichtig, für jedes Projekt einen Abbildung 2: Zum Speichern eigenen Ordner anzulegen. Wir speichern zwei Dateien und legen dabei zwei Namen fest. Im Hintergrund verwaltet Lazarus jedoch mehrere Dateien, die alle im Projektordner abgelegt werden. Verwechslungen mit gleichnamigen Dateien in einem Ordner oder fehlende Dateien können dazu führen, dass das Programm nicht mehr funktioniert. Wie in Abbildung 2 dargestellt wählen wir im 3

4 Menü den Punkt Projekt - Projet speichern unter... und folgen dem Speichern-Dialog. Am linken Rand des Bildschirms finden wir den zweigeteilten Objektinspektor (Abb. 3), der uns Abbildung 3: Objektinspektor hilft, unser Projekt zu verwalten. Im oberen Teil finden wir eine Liste der im Projekt vorhandenen Objekte (in der Abb. links). Bei einem neuen Projekt ist dort zunächst nur ein Objekt aufgeführt, das leere Formular. Im unteren Teil (in der Abb. rechts) finden wir eine Liste von Eigenschaften (Attributen) des gerade ausgewählten Objekts. Jede dieser Eigenschaften wird später innerhalb des Programms als Variable eines bestimmten Datentyps verwaltet. Wichtige Attribute sind z.b. *.name: Name des Objektes - string; *.caption: Sichtbare Beschriftung des Objekts - string; *.width / *.hight: Höhe und Breite des Objektes - integer; Manche Attribute wie name besitzt jedes Objekt, andere wie caption sind typisch für einige Objekete oder sogar nur individuell in einem Objekt verfügbar. Wir können andieser Stelle unserem Formular, das wir noch nicht sehen einen Namen geben. Wichtig bei allen Änderungen ist, dass der Name eines Objektes immer nur im Objektinspektor geändert wird. Er steht auch im Quellcode. Bei einer Änderung im Objektinspektor wird diese Änderung jedoch automatisch an alle Verwendungen übernommen, bei einer lokalen Änderung an einer Stelle im Quellcode nicht. Der Quellcode selbst steht im dritten Fenster, das im Zentrum des Bildschirms zu sehen ist. Mit diesem Quellcode beschäftigen wir uns später. Jetzt machen wir zunächst durch Umschalten mit der 4

5 Funktionstaste F12 das Formular (Abb. 6) sichtbar. Das Formular ist das sichtbare Windowsfenster des fertigen Programms. Formular und Quellcode gehören fest zusammen. Durch die Funktionstaste F12 kann man zwischen beiden Fenstern wechseln. Wir wollen jetzt ein Formular für eine Ampelsimulation gestalten 1. Dabei werden wir einige Objekttypen und ihre wichtigsten Attribute kennen lernen. Zunächst ziehen wir als Rahmen für das Objekt Uhr eine GroupBox auf dem Formular. In dieser Box platzieren wir drei Labelfelder zur Anzeige der Teile der Uhrzeit. Die Uhrzeit besteht aus der Stundenzahl, einem Doppelpunkt zur Trennung der Zahlen und der Minutenzahl. Diese Texte werden in der Eigenschaft caption des Labels verwaltet. Daher tragen wir im Objektinspektor die Starttexte ein. Hier gleich ein Tipp: Die Labelfelder passen ihre Größe automatisch an den Text an. Es ist oft hilfreich, wenn wir dies unterbinden mit der Festlegung der Eigenschaft autosize auf false. Insgesamt nehmen wir für die Labelfelder folgende Einstellungen vor: Alignment: tacenter zentriert in der Breite; Autosize: false; Caption: 00; :; 00; Font: Schriftart und Größe wählen; Height: Höhe des Feldes festlegen; Layout: tlcenter zentriert in der Höhe; Left: linken Rand festlegen; Top: Oberrand festlegen; Width: Breite festlegen. Abbildung 4: Formular zur Uhr Außerdem können wir die Namen für die GroupBox und das gesamte Formular sinnvoll wählen. Für die Ablaufsteuerung benötigen wir noch einen Timer als Taktgeber. Diesen finden wir in der Werkzeugleiste System. Er wird auf dem Formular platziert, ist aber nachher im laufenden Programm unsichtbar. Außedem benötigen wir noch zwei sinvoll beschriftete Button als Schaltfläche zum Starten und Stoppen der Uhr. Damit erhalten wir als Ergebnis ein fertiges Windows-Fenster wie in Abbildung 4. An dieser Stelle können wir einen kleinen Test durchführen. Wir wählen in der Menüleiste Start 1 1 AB Objekte und Eigenschaften 5

6 - Kompilieren. Dann wird das Programm in Maschinensprache übersetzt. Dabei kontrolliert der Compiler den Quelltext auf Syntaxfehler und erzeugt und speichert die ausfürbahre Datei. Diese finden wir anschließend im Projektordner. Da noch kein Quelltext geschrieben wurde, dürften auch keine Fehlermeldungen erscheinen. Jetzt starten wir das Programm durch Anwahl des grünen Dreiecks links in der Werkzeugleiste. Das Programm wird noch einmal kompiliert und dann gestartet. Leider kann es noch nichts, da wir noch nichts programmiert haben. Um das zu tun, schließen wir das laufende Programm wieder. Dies ist bei jedem Test wichtig: Bevor wir Veränderungen am Formular oder am Quelltext vornehmen, schließen wir immer das laufende Programm. Jetzt können wir uns an die Programmierung der Uhr wagen. Dazu erzeugen wir durch die Doppelklick mit der Maus auf die auslösenden Objekte die notwendigen Prozeduren. Der Start-Button soll den Timer starten: Der Befehl besteht aus fünf Teilen: timer1.enabled:=true; timer1 ist der name des Objektes, das wir verändern wollen. enabled ist das zu verändernde Attribut. Beides wird durch einen Punkt getrennt. := bezeichnet eine Wertzuweisung, die unbedingt unterschieden werden muss von einem reinen Wertevergleich mit = ohne den Doppelpunkt. true ist der neue Wert, den unsere Objekteigenschaft erhält. ; Das Semikolon trennt diesen Befehl von dem nächsten. Zwischen zwei Befehlen muss ein Semikolon stehen. Dies ist ein wichtiges Satzzeichen in Turbopascal. Hinter dem letzten Befehl einer Prozedur muss kein Semikolon mehr stehen, darf aber. Der Stopp-Button soll den Timer stoppen: timer1.enabled:=false; Die eigentliche Ablaufsteuerung erfolgt durch den Timer. Der Timer gibt in festgelegten Intervallen ein Signal. Jedesmal beim Auslösen des Signals wird die OnTimer-Prozedur abgearbeitet. In dieser Prozedur benötigen wir zwei Variablen, die wir im Prozedurkopf deklarieren: VAR min, std : integer; Der Zusatz integer legt den Datentyp fest. Zunächst lesen wir die aktuellen Zahlen von der Uhr: std := StrToInt(label1.caption); min := StrToInt(label3.caption); Der Befehl StrToInt wandelt die Textvariable label1.caption um in eine Zahlenvariable vom Typ Integer, damit wir mit dieser Zahl auch rechnen können. Nun erhöhen wir einfach die Minutenzahl um 1: min := min + 1; Wird die volle Stunde erreicht, muss die Minute auf 0 gestellt und die Stunde erhöht werden: IF min=60 THEN BEGIN min := 0; std := std + 1; END; 6

7 Jetzt müssen wir noch die korrekte Ausgabe erzeugen. Dabei müssen wir beachten, dass bei einstelligen Zahlen die Null vorgesetzt wird. Außerdem müssen wir die Zahl wieder in eine Textvariable umwandeln mit IntToStr : IF min < 10 THEN label3.caption := 0 + IntToStr(min) ELSE label3.caption := IntToStr(min); IF std < 10 THEN label1.caption := 0 + IntToStr(std) ELSE label1.caption := IntToStr(std); Abbildung 5: Die Prozeduren zur Uhrsteuerung Insgesamt erhalten wir also drei Prozeduren wie in Abbildung 5. Wir erkennen gut die Einrücken. Für spätere Korrekturen und Ergänzungen ist es wichtig, Anfang und Ende einer Bedingung oder Schleife zu finden, insbesondere, wenn diese ineinander geschachtelt sind. Dabei hilft es, durch saubere Einrückungen diese Strukturen optisch sichtbar zu machen. Nun Testen wir das Programm. Der grüne Pfeil in der Menüleiste links oben kompiliert und startet dass Programm. Für eine Nutzung des fertigen Programms auf einem anderen Rechner wird lediglich die bei der Kompilierung erzeugte *.EXE-Datei benötigt. Zum Schluss fassen wir die wichtigsten Erkenntnisse noch einmal zusammen. Ein Formular ist leicht zu gestalten, da wir alle Objekte aus der vielfältigen Werkzeugleiste entnehmen können. Etwas Zeit sollte man sich für die Einstellung der Startwerte und Beschriftungen der einzelnen Objekte nehmen. Dabei sind sinvolle Namen und Beschriftungen für die spätere Programmierung hilfreich. In den Namen dürfen keine Umlaute oder sonstigen Sonderzeichen verwendet werden. Für die Veraltung der Daten benötigen wir Variablen, die im Prozedurkopf deklariert werden müssen. Dabei ist der Datentyp festzulegen. Außerdem müssen wir beim Einlesen der Werte häufig den Typ umwandeln, da alle Beschriftungen auf den Objekten als Textvariable vom Typ STRING verwaltet werden, wir zum Rechnen aber Zahlen vom Typ INTEGER oder REAL benötigen. Entsprechend ist bei der Ausgabe eine Rückumwandlung erforderlich. Mit Datentypen müssen wir uns noch ausführlich beschäftigen. Manche Berechnungen sind an Bedingungen geknüpft. Dazu können wir eine bedingte Anweisung oder Verzweigung in Form der IF-Anweisung verwenden. Neben diesen Bedingungen gibt es auch Schleifen und andere algorithmische Strukturen, mit denen wir uns noch ausführlich beschäftigen werden. Ein Programm ist grundsätzlich in Prozeduren gegliedert. Diese Prozeduren lassen sich in Lazarus leicht erzeugen. Auch die genauere Struktur eines Programms werden wir noch genauer betrachten. 7

8 1.2 Ampelsimulation - Programmstruktur in Lazarus Wir wollen jetzt ein Formular für eine Ampelsimulation gestalten 2. Dabei werden wir weitere Objekttypen und ihre wichtigsten Attribute kennen lernen. Außerdem erhalten wir einen ersten Einblick in die Programmstruktur. Abbildung 6: Formular Abbildung 7: Einfügen eines Shapes Zunächst bauen wir zwei sichtbare Ampeln, eine Fußgängerampel mit zwei Feldern für rot und grün, und eine Fahrzeugampel mit drei Feldern. Dazu platzieren wir eine GroupBox aus der Werkzeugleiste Standard auf dem Formular und ziehen bei angewählter Groupbox zwei Shape aus der Werkzeugleiste Additional in die Box. Jetzt stellen wir im Objektinspektor die Eigenschaften richtig ein. name: fussoben (Umlaute und ß gibt es in Objektnamen nicht); shape: stcircle (Festlegung der Form); Brush/Color: clred (Festlegung der Farbe). Position und Größe können wir einfach durch Ziehen mit der Maus einstellen oder konkret im Objektinspektor eintragen. Analog fügen wir jetzt das grüne Licht ein und bauen anschließend die Fahrzeugampel. Als Ergebnis erhalten wir ungefähr die Darstellung in Abb. 8. Am unteren sind bereits zwei Schultflächen (TButton) zu sehen, die wir aus der Leiste Standard entnehmen und gestalten können. Mit diesen Schaltflächen starten und beenden wir nachher das laufende Programm. 2 3 AB Programmstruktur 8

9 Abbildung 8: Ampelgestaltung Außerdem benötige wir wieder einen Timer zur Ablaufsteuerung. Wir wechseln kurz ins Quelltextfenster (F12) und schauen uns den bereits vorhandenen Quelltext an. Dabei lernen wir einen Teil der Struktur eines Programms kennen. Das Lazarus-System erzeugt bei der Erzeugung eines neuen Projektes immer schon den Rahmen des Quellcodes: In der ersten Zeile steht hinter dem Befehl unit der Name der Unit; Es folgen zwei Steuerungsbefehle für die Einbindung der Unit in das Projekt; Mit dem Befehl uses werden Programmpakete eingebunden, in denen die Programmierbefehle abgelegt sind. Neben den Standardpaketen können wir später bei Bedarf von Hand weitere Pakete ergänzen. Mit dem Befehl TYPE wird aus dem Standardformular ein neuer Objettyp TForm1 erzeugt. Dabei werden alle zum Objekt/Formular gehörenden Objekte aufgelistet. Wir finden dort die von uns bereits eingefügten Objekte. Später erscheinen hier auch die Prozeduren. Der Befehl VAR leitet die Variablendeklaration ein. Vorhanden ist bereits eine Variable Form1 vom Datentyp TForm1. Die Namen sind natürlich identisch mit den von uns im Objektinspektor festgelegten Namen für das Formular. Hier werden wir später weitere Variable deklarieren. Wichtig ist, die Namen niemals im Qulltext zu ändern, sonder immer im Objektinspektor. Jeder Name wird an vielen Stellen - zum Teil auch versteckt - verwendet. Durch die Änderung im Objektinspektor übernimmt das System den neuen Namen an alle Verwendungen im Programm. Zwischen implementation und initialization erzeugen wir in der Folge in Form von Prozeduren die Algorithmen, die den Programmablauf steuern. Jetzt wollen wir unsere Prozedur erzeugen und den Programmablauf festlegen. Dazu haben wir zwei Möglichkeiten. Unsere Prozedur soll mit dem Start-Button verbunden sein. Daher können wir durch Doppelklick auf diesen Button im Quelltext den Rahmen der zugehörigen Prozedur erzeugen. Im Objektinspektor finden wir jetzt bei diesem Button unter Ereignisse neben dem Ereignis OnClick den Namen der erzeugten Prozedur (Abb. 9). Damit sind wir bei der zweiten Erzeugunsgmethode. Wir können auch direkt hier im Objektinspektor ein Ereignis wählen und dort die Prozedur zuordnen, falls sie schon existiert, oder neu erzeugen. Jetzt geht es an die Programmierung. Diese besteht im einfachsten Fall aus Wertzuweisungen an bestimmte Variable. Die Ampelsteuerung erfolgt wie bei der Uhr durch den Timer. Dazu gibt es eine Prozedur OnTimer unter den Ereignissen eines Timers. Diese wird auf jeden Taktschlag des 9

10 Abbildung 9: Prozedurerzeugung Abbildung 10: Timerprozeduren Timers einmal abgearbeitet, d.h. wir haben gleichsam eine Wiederholungsschleife zur Verfügung, die solange läuft, bis wir den Timer anhalten. Die Steuerung der Ampel besteht jetzt einfach darin, die einzelnen Lichter/Shapes sichtbar oder unsichtbar zu schalten durch Befehle wie shape1.visible:=false; Abbildung 11: Fehlermeldung Jetzt können wir das Programm testen wie oben beschrieben. Nach der Korrektur eventueller Syntaxfehler sollte die Ampel laufen. Häufig erscheint eine Fehlermeldung wie in Abb. 11. Dann liegt der Fehler oft in der Zeile oberhalb der Markierung. In diesem Fall fehlt dort das Semikolon zur Befehlstrennung. Der Ablauf ist jedoch noch nicht realistisch, da alle Ampelphasen gleich lang sind. Dies liegt daran, dass der Timer ein festes Impulsintervall besitzt. Wir können dieses Intervall aber ändern, indem wir am Ende der Prozedur durch den Befehl 10

11 timer1.interval:=400; die neue Intervalllänge festlegen. Die Zahl gibt die Wartezeit bis zum nächsten Impuls in Millisekunden an. Diese Lösung hilft aber nur, wenn wir verschiedene Ampelphasen unterscheiden. Wir müssen also in unserer OnTimer-Prozedur für jede der Phasen eine eigene Befehlsfolge erstellen und jeweils am Ende die Länge der Phase festlegen. Beim Aufruf der Prozedur durch den Timerimpuls muss der Prozessor jetzt aber wissen, welche der Befehlsfolgen abgearbeitet werden soll. Dazu unterscheiden wir diese mit Hilfe einer Variable phase vom Datentyp integer durch bedingte Anweisungen in der Form IF phase=1 THEN BEGIN [Auflistung der Befehle] END Die Schlüsselwörter IF - THEN knüpfen die Ausführung der folgenden Befehle an die Bedingung zwischen diesen Wörtern. Die Schlüsselwörter BEGIN - END bilden eine Klammer, so dass alle Befehle innerhalb dieser Klammer an die Bedingung geknüpft werden. Ohne die Klammerung durch BEGIN - END wäre nur der erste direkt danach folgende Befehl an die Bedingung geknüpft, und alle weiteren Befehle würden in jedem Fall ausgeführt. Die Variable phase müssen wir hinter dem Befehl VAR vor den Prozeduren deklarieren: phase : integer; Jetzt können wir beliebig viele Phasen programmieren, wobei am Ende jeder Befehlsfolge das Timerintervall und die Nummer der folgenden Phase festgelegt wird. Die dritte Phase könnte dann so aussehen: IF phase=3 BEGIN foben.visible:=true; funten.visible:=false; aoben.visible:=true; amitte.visible:=true; aunten.visible:=false; timer1.interval:=500; phase:=4; END So wird das Programm allerdings anders funktionieren, als wir es wollen. In der ersten Phase wird die am Ende die Phase auf den Wert 2 gesetzt, so dass jetzt die nächste IF - Bediungung erfüllt wird und sofort im selben Prozedurdurchlauf auf dem gleichen Timerimpuls auch Phase 2 durchlaufen wird. Letztlich werden daurch alle Phasen auf jedem Timerschlag durchlaufen und dabei gleichzeitig die eingestellte Phasenlänge ignoriert. Dieser Fehler wird behoben, wenn wir die Phase nicht in jeder Befehlsfolge einzeln setzen, sondern wenn wir hinter den IF - Befehlen am Ende der Timerprozedur nur einmal die Variable hochzählen. Dann müssen wir allerdings bei der letzten Phase - etwa 7 - wieder auf 1 zurücksetzen: Fassen wir noch einmal zusammen: phase := phase + 1; IF phase = 8 THEN phase := 1; Wir kennen die Arbeitsbereiche der Programmentwicklungsumgebung LAZARUS : Menüleiste, Werkzeugleiste, Objektinspektor, Formularfenster und Quelltextfenster. Wir kennen die ersten Objekte zur Formulargestaltung: TForm1(Formular), TGroupBox(Gruppenbox), TLabel(Anzeigefeld), TShape(Formen), TButton(Schaltfläche), TTimer(Uhr). 11

12 Abbildung 12: Uhrprozedur Wir kennen die wichtigsten Eigenschaften der Objekte:.name, *.caption, *.hight, *.visible, *.enabled, *.autosize, *.font. Wir wissen, wie wir die Werte dieser Attribute durch Befehle im Quellcode verändern können. Wir wissen, wie wir eine Prozedur erzeugen und einem Ereignis zuordnen können. Wir wissen, wie wir ein Projekt erzeugen, speichern, kompilieren und ausführen. Zum besseren Verständnis sollten wir uns noch die Gesamtstruktur des Projektes ansehen. Im Hintergrund gibt es eine Projektdatei project1.lpr, welche alle Dateien des Projektes miteinander verbindet. Den Quelltext dieser Datei können wir uns ansehen unter Projekt - Quelltext anzeigen. Wir sehen, dass hier die Unit und das zugehörige Formular eingebunden werden. Dabei muss die Projektdatei natürlich wissen, wo diese Dateien liegen und wie sie heißen. Deshalb ist es so wichtig, alle Dateien in einem Ordner zu behalten und keine Namen ohne den Objektinspektor zu verändern. Grundsätzlich können wir mehrere Units mit jeweils einem eigenen Formular in einem Projekt zusammenführen. Dies wird vielleicht später bei größeren Programmen notwendig. Innerhalb jeder Unit gibt es jetzt Prozeduren, die bei bestimmten Ereignissen aufgerufen und aus- Abbildung 13: Struktur eines Lazarus-Projektes geführt werden. Dadurch erhalten wir die in Abb. 13 dargestellte Programmstruktur. Später werden wir innerhalb einer Unit untergeordnete Prozeduren verwenden, die von den übergeordneten aufgerufen werden. Dadurch entsteht unten eine weitere Zugriffsebene. Eine Programmiersprache wie Lazarus stellt uns verständliche Befehle zur Verfügung, mit denen wir Formulare gestalten und Propgrammabläufe festlegen können. Diese Sprache kann jedoch kein Prozessor verstehen. Der Prozessor versteht nur Abfolgen von 0 und 1, die für offene bzw. geschlossene Stromkreise stehen. Wir könnten natürlich jedes Programm direkt aus eine solchen Abfolge von Ziffern erstellen. Dazu müssten wir aber viele Spezialkenntnisse über den Prozessor besitzen 12

13 und alle ASCII-Codes für jedes Zeichen kennen. Dies wäre viel zu umständlich und fehlerträchtig. Deshalb wurden Programmiersprachen entwickelt. Ein Quelltext, der jetzt in so einer Sprache geschrieben wurde, muss vor dem Ablauf dann in die Maschinensprache übersetzt werden. Dies leistet der Kompiler. Er übersetzt die Befehle und erzeugt die ausführbare Datei, die jetzt den fertigen, für den Prozessor verständlichen Maschinencode enthält. 1.3 Programmiersprachen - Syntax und Semantik Ein lauffähiges Programm muss letztendlich in der Maschinensprache Assembler an den Rechner geliefert werden. Diese Programme bestehen nur aus Ziffernkolonnen von 1 und 0 bzw. aus Zusammenfassungen von je acht solchen Zeichen zu einer Hexadezimalzahl. Das Schreiben solcher Programme ist sehr schwierig und aufwendig und setzt die Kenntnis von rechnerinternen Geräteadressen voraus. Daher gibt es höhere Programmiersprachen, bei denen ein Compiler, also ein Übersetzungsprogramm den sogenannten Quellcode in die Maschinensprache übersetzt. Damit hat der Programmierer die Möglichkeit, seine Anweisungen in halbwegs verständlicher Form zu formulieren. Man unterscheidet heute drei Gruppen von Programmiersprachen: imperative Sprachen; funktionale Sprachen; deklarative Sprachen. Programme in imperativen Sprachen sind aus Unterprogrammen, sogenannten Prozeduren aufgebaut und benutzen verschiedene Datentypen, wobei im Programm Namen für die Variablen vereinbart werden müssen, und zu jeder Variablen ein bestimmter Speicherplatz im RAM gehört. Die Programme selbst bestehen dann aus einer Abfolge von Anweisungen, die der Computer der Reihe nach abarbeitet, wobei jedes Mal in irgend einer Weise die Speicherbelegung geändert wird. Beispiele für solche Sprachen sind Basic; Pascal; Delphi; C++; Java; Modula-2. In funktionalen Sprachen werden alle Daten als Funktionswerte behandelt. Daher werden keine Speicherplätze dauerhaft belegt, weshalb auch keine Variablennamen vereinbart werden müssen. Alle Anweisungen werden als Wertezuweisung wie bei Funktionen geschrieben.beispiele sind hier: ML; Lisp. Deklarative Sprachen legen eine Vielzahl von Beziehungen fest, z.b. Verwandschaftsbeziehungen nach Muster x ist Mutter von y. Daraus lassen sich dann viele weitere Beziehungen ableiten. Ein Beispiel für solche Sprachen ist PROLOG. 13

14 Die Wahl einer geeigneten Programmiersprache ergibt sich aus dem zu lösenden Problem. So ist Pascal ursprünglich für die Verwaltung von Personaldaten, also überwiegend den Umgang mit Textvariablen entwickelt worden. FORTRAN dagegen ist eine mathematische Sprache, die vor allem in der Physik weit verbreitet ist. Jede dieser Sprachen besitzt genau wie jede natürliche Sprache bestimmte Bildungsregeln. Dazu gehören der Vorrat an verwendbaren Zeichen, also die Buchstaben, Ziffern und Satzzeichen; die zur Sprache gehörenden Wörter, also die erlaubten Buchstabenkombinationen; die Regeln zur Satzbildung inklusive der Zeichensetzung; die Festlegung der Bedeutung von Zeichen, Wörtern und Sätzen. In natürlichen Sprachen spechen wir hier vom Alphabet, der Rechtschreibung, der Grammatik und der Semantik (Bedeutungslehre). In der Sprachtheorie werden je nach Betrachtungsweise mehrere Aspekte zur Syntatik oder zur Syntaxeiner Sprache gezählt. Bei Programmiersprachen zählen wir alles, was mit korrekter Schreibweise zu tun hat, zur Syntax. Die Syntax muss vom verwendeten Zeichen bis zur Grammatik absolut korrekt sein. Im Gegensatz zum menschlichen Gehirn, dass ein Wort auch dann noch erkennt und versteht, wenn es falsch geschrfieben ist oder an falscher Stelle im Satz steht, kann das Elektronenhirn ein Wort oder einen Satz nur durch zeichenweises Vergleichen mit dem im Speicher abgelegten Vorrat erlaubter Strukturen erkennen. Jeder Fehler führt zur Nichterkennung und damit zu einer Fehlermeldung oder zum Programmabbruch. Jede Programmierumgebung enthält entweder eine Interpreter oder einen Compiler. Diese prüfen den Qulltext auf syntaktische KOrrektheit und melden uns eventuelle Fehler, so dass wir diese korrigieren können. Ein Interpreter nimmt immer nur einen Befehl, übersetzt ihn und führt ihn aus. Daher kann das Programm immer nur auf einem Rechner ausgeführt werden, auf dem auch die Programmiersprache installiert ist. Dafür geht das wesentlich schneller als die Arbeit mit einem Compiler. Ein Compiler prüft zunächst das gesamte Programm, übersetzt das in Maschinensprache und erzeugt ein lauffähiges Programm. Dieser Voirgang dauert etwas läönger, dafür entsteht aber auch eine ausführbare Datei, die für sich allein auf jedem Rechner laufen kann. 14