Pascal (1970)

1. Hello, world!

Pascal-Pro­gramme werden in Textdateien mit der Endung .pas geschrieben. Diese Da­tei­en werden anschließend von einem Compiler in ausführbare Da­tei­en übersetzt, die auf deinem Com­puter direkt ausgeführt werden können. Früher waren der Compiler »Turbo Pascal« sehr verbreitet, heute wird meist der freie Compiler »Free Pascal« ver­wen­det.

Stelle zuerst sicher, dass du keinen Ordner geöffnet hast. Um sicherzugehen, drücke einfach den Shortcut für »Ordner schließen«: StrgK und dann F. Dein Work­space sollte jetzt ungefähr so aussehen:

Quelltext schreiben

Klicke auf »New File« und wähle als Dateityp »Text File«.

Schreibe nun den folgenden Code in die Datei:

1
2
3
4
5

program HelloWorld;

begin
    WriteLn('Hello, World!');
end.

Da Visual Studio Code noch nicht weiß, dass es sich um Pascal-Quelltext handelt, ist dein Programm momentan noch einfarbig, aber das wird sich gleich ändern. An dem weißen Punkt erkennst du, dass deine Änderungen noch nicht gespeichert sind.

Drücke nun StrgS, um die Datei zu speichern. Gib hello.pas ein – der vollständige Pfad zu deiner Datei lautet dann /workspace/hello.pas.

Da Pascal standardmäßig nicht von Visual Studio Code un­ter­stützt wird, müssen wir noch eine passende Er­wei­te­rung installieren. Klicke dazu auf das Er­wei­te­rungs-Symbol in der Seitenleiste oder drücke StrgShiftX. Suche nach der Er­wei­te­rung »Pascal Magic« und installiere sie.

Alternativ kannst du auch StrgP drücken und ext install theangryepicbanana.language-pascal eingeben, um die Er­wei­te­rung zu installieren.

Anschließend solltest du dein Pascal-Programm farbig sehen:

Kompilieren und ausführen

Bevor wir das Programm ausführen können, müssen wir es kompilieren. Dadurch wird der Quelltext in Maschinencode übersetzt, den dein Com­puter ausführen kann.

Öffne dazu ein Ter­mi­nal, indem du entweder StrgJ drückst oder das Panel-Symbol rechts oben drückst. Dein Fenster sollte jetzt ungefähr so aussehen:

Um das Programm zu kompilieren, gib folgenden Befehl ein:

fpc hello.pas

Wenn du keinen Fehler gemacht hast, wird das Programm erfolgreich kompiliert und die ausführbare Datei hello wird im selben Verzeichnis erstellt. Du kannst dies überprüfen, indem du dir die Da­tei­en im aktuellen Verzeichnis mit ls oder ls -l anzeigen lässt:

Die grüne Datei hello ist die ausführbare Datei – im Unterschied zu Win­dows, wo ausführbare Da­tei­en die Endung .exe haben, haben ausführbare Da­tei­en unter Linux keine Endung. Um das Programm auszuführen, gib folgenden Befehl ein:

./hello

Das Programm sollte die Nachricht Hello, World! im Ter­mi­nal ausgeben. Du kannst beide Schritte auch in einem Befehl kombinieren:

fpc hello.pas && ./hello

Fehler finden und beheben

Wenn du einen Fehler im Code machst, wird der Compiler eine Fehlermeldung ausgeben. Versuche zum Beispiel, statt WriteLn das Wort WritLn zu schreiben:

    WritLn('Hello, World!');

Speichere die Datei und führe den Compiler erneut aus:

fpc hello.pas

Der Compiler sollte eine Fehlermeldung ausgeben, die dir hilft, den Fehler zu finden:

Es lohnt sich, die Fehlermeldungen genau zu lesen, um den Fehler zu finden und zu beheben. Achte auf die Zeilennummer (in diesem Beispiel 4) und den Text, der dir sagt, was falsch ist. Denke daran, den Fehler wieder zu beheben, bevor du das nächste Beispiel ausprobierst.

2. Primfaktorzerlegung

Im zweiten Beispiel wollen wir eine Zahl in ihre Primfaktoren zerlegen. An diesem Beispiel kannst du sehen, wie man in Pascal Be­nut­zer­ein­ga­ben verar­bei­tet und Schleifen ver­wen­det. Erstelle eine neue Datei mit StrgAltN und schreibe den folgenden Code hinein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

program Factor;

var
    number, i: integer;

begin
    Write('Enter a number: ');
    ReadLn(number);

    Write('Factors of ', number, ': ');
    for i := 2 to number do begin
        while number mod i = 0 do begin
            if number mod i = 0 then begin
                write(i, ' ');
                number := number div i;
            end;
        end;
    end;
    WriteLn;
end.

Speichere die Datei unter dem Namen factor.pas. Kompiliere das Programm:

fpc factor.pas

Falls du keine Fehlermeldung erhältst, kannst du das Programm ausführen und testen:

Das Programm hat die Zahl 123 in ihre Primfaktoren zerlegt und ausgegeben. Probiere aus, was passiert, wenn du die Zahl 100000 eingibst. Was könnte der Grund dafür sein?

3. Bubblesort

Im dritten Beispiel wollen wir eine Liste von 10 Zufallszahlen sortieren. Dafür verwenden wir den Bubblesort-Al­go­rith­mus, der zwar nicht besonders effizient ist, aber sehr einfach zu verstehen und zu implementieren. Der Bubblesort-Al­go­rith­mus funktioniert, indem er die Liste mehrmals durchläuft und benachbarte Elemente vertauscht, wenn sie in der falschen Reihenfolge sind.

An diesem Beispiel kannst du sehen, wie man in Pascal Arrays ver­wen­det und Schleifen verschachtelt.

Erstelle eine neue Datei und schreibe den folgenden Code hinein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

program BubbleSort;

const
    SIZE = 10;

var
    arr: array[1..SIZE] of Integer;
    i, j, temp: Integer;

begin
    Randomize;

    // Fill the array with random integers
    for i := 1 to SIZE do
        arr[i] := Random(100);

    // Print the original array
    Write('Original array: ');
    for i := 1 to SIZE do
        Write(arr[i], ' ');
    WriteLn;

    // Bubble sort algorithm
    for i := 1 to SIZE - 1 do begin
        for j := 1 to SIZE - i do begin
            if arr[j] > arr[j + 1] then begin
                temp := arr[j];
                arr[j] := arr[j + 1];
                arr[j + 1] := temp;
            end;
        end;
    end;

    // Print the sorted array
    Write('Sorted array: ');
    for i := 1 to SIZE do
        Write(arr[i], ' ');
    WriteLn;
end.

Speichere die Datei unter dem Namen bubblesort.pas. Kompiliere das Programm:

fpc bubblesort.pas

Falls du keine Fehlermeldung erhältst, kannst du das Programm ausführen und testen:

Das Programm hat eine Liste von 10 Zufallszahlen sortiert. Versuche, den Quelltext so zu verändern, dass statt 10 Zahlen 100 oder mehr Zahlen sortiert werden.

4. Pro­gram­mier­en wie in den 90ern

Wenn du möchtest, kannst du eine kleine Zeitreise machen und wie früher in den 90ern programmieren. Vergrößere dein Ter­mi­nal und gib einfach fp bubblesort.pas ein:

In dieser Ent­wick­lungs­um­ge­bung kannst du den Quelltext direkt bearbeiten und du kannst folgende Tasten verwenden:

Bevor du ein Programm kompilieren kannst, musst du der Ent­wick­lungs­um­ge­bung allerdings noch einen Hinweis geben, wo die benötigten Units zu finden sind. Klicke dazu auf »Options« und »Directories…«:

…und trage dann den Pfad /usr/lib/x86_64-linux-gnu/fpc/3.2.2/units/x86_64-linux/* ein:

5. Zusammenfassung

In diesem Kapitel hast du an drei Beispielen gesehen, wie man ein einfaches Pascal-Programm schreiben, kompilieren und ausführen kann. Das ist natürlich nur ein erster Eindruck. Um Pascal wirklich zu beherrschen, musst du noch viel mehr lernen – am besten, indem du eigene Pro­gramme schreibst und ausprobierst. Die Buchhandlungen, Bib­lio­theken und Youtube sind voll von Material für dich. Viel Spaß beim Pro­gram­mier­en!