Pascal und Delphi – strukturierte Programmierung

Pascal (Niklaus Wirth, 1970) wurde als Lehr- und Systemsprache entwickelt und ist bekannt für klare Struktur, strenge Typisierung und lesbaren Code. Delphi (Embarcadero, früher Borland) erweitert Pascal zu Object Pascal mit Klassen, Properties und einer visuellen Entwicklungsumgebung (VCL/FMX). Der freie Compiler Free Pascal (fpc) mit der IDE Lazarus hält die Sprache am Leben.

Compiler

• fpc --version – Version prüfen
• fpc prog.pas – kompilieren (erzeugt prog)
• fpc -O2 prog.pas – mit Optimierung
• fpc -gl prog.pas – Debug-Info (gdb) einbinden
• Delphi/Windows: dcc32 prog.dpr (Kommandozeilen-Compiler)

Basissyntax

program hallo;
uses crt;
var
  name: string;
begin
  write('Wie heisst du? ');
  readln(name);
  writeln('Hallo, ', name, '!');
end.

• program – Programmkopf, uses – Units/Bibliotheken einbinden
• var – Variablendeklaration: i: integer; x: real; s: string; ok: boolean; c: char;
• const – Konstanten: const pi = 3.14159;
• type – eigene Typen/Records: type Punkt = record x, y: integer; end;
• Blöcke: begin ... end (Ende des Programms mit end. – Punkt!)

Kontrollstrukturen

if x > 0 then
  writeln('positiv')
else
  writeln('negativ');

case n of
  1: writeln('eins');
  2: writeln('zwei');
else
  writeln('anders');
end;

for i := 1 to 10 do
  writeln(i);

while x < 100 do
  x := x * 2;

repeat
  readln(eingabe)
until eingabe = 'ende';

Prozeduren und Funktionen

function quadrat(x: integer): integer;
begin
  quadrat := x * x;   { Pascal weist das Ergebnis dem Funktionsnamen zu }
end;

procedure begruesse(name: string);
begin
  writeln('Hallo, ', name);
end;

Object Pascal / Delphi

type
  TPerson = class
  private
    FName: string;
  public
    constructor Create(aName: string);
    procedure Vorstellen;
  end;

constructor TPerson.Create(aName: string);
begin
  FName := aName;
end;

procedure TPerson.Vorstellen;
begin
  writeln('Ich bin ', FName);
end;

• Klassen: class mit private/public-Bereichen
• Properties: property Name: string read FName write FName;
• Vererbung: TKind = class(TPerson)
• Units: jede Unit in eigener .pas-Datei mit interface/implementation

Unit-Aufbau (Free Pascal / Lazarus)

unit meineunit;

interface
function verdoppeln(x: integer): integer;

implementation
function verdoppeln(x: integer): integer;
begin
  verdoppeln := x * 2;
end;

end.

Verwandte Einträge: C und C++ für Systemprogrammierung, Python für moderne Alternativen, sowie die Glossar-Begriffe Compiler, Adresse (Speicher) und Stack.

GraphQL ist eine Abfragesprache für APIs, die 2015 von Facebook entwickelt wurde. Anders als bei REST ruft der Client genau die Felder ab, die er braucht — in einer einzigen Anfrage.

Grundstruktur einer Query

query {
  user(id: 42) {
    name
    email
  }
}

Eine Mutation verändert Daten, eine Subscription empfängt Live-Updates:

mutation { createUser(name: "Anna") { id } }
subscription { newMessage { text } }

Schema und Typen

type User {
  id: ID!
  name: String!
  email: String
}

Ausrufezeichen (!) bedeutet: Feld ist Pflicht. ID, String, Int, Float, Boolean sind die eingebauten Skalartypen.

Variablen und Aliase

query GetUser($id: ID!) {
  user(id: $id) { name }
}

Praxis-Tipps

• Ein Endpunkt (z.B. /graphql), eine POST-Anfrage — kein Overfetching und kein Underfetching.
• Zum Testen eignen sich Tools wie GraphiQL oder Altair.
• Fehler kommen als errors-Array in der Antwort, nicht als HTTP-Statuscode.

Verwandte Grundlagen: SQL-Befehle und Python-Befehle.

Markdown ist eine leichtgewichtige Auszeichnungssprache, mit der man Text mit einfachen Zeichen formatieren kann — ideal für Dokumentation, README-Dateien, Foren und Wikis. Der Klartext bleibt lesbar, HTML-Ausgabe entsteht automatisch.

Überschriften und Text

# H1
## H2
### H3

**fett**, *kursiv*, ~~durchgestrichen~~

Listen und Links

- Punkt 1
- Punkt 2

1. Erster
2. Zweiter

[Linktext](https://example.org)

Code und Tabellen

`inline code`

```python
print("Hallo")
```

| Spalte A | Spalte B |
|----------|----------|
| Wert 1   | Wert 2   |

Praxis-Tipps

• Die meisten Plattformen (GitHub, GitLab, Joomla) unterstützen Markdown direkt oder per Erweiterung.
• Für Sonderzeichen HTML einbetten:   für geschütztes Leerzeichen.
• Dateiendung: .md oder .markdown.

Verwandte Grundlagen: HTML & CSS und YAML, TOML, JSON.

grep ist der Standardbefehl unter Linux und macOS, um Textmuster (reguläre Ausdrücke) in Dateien und Ausgaben zu suchen. Der Name steht für global regular expression print.

Grundlagen

grep "fehler" logfile.txt      # Zeilen mit 'fehler' anzeigen
grep -i "error" *.log          # Groß/klein ignorieren
grep -r "TODO" src/            # rekursiv im Verzeichnis suchen

Wichtige Optionen

grep -v "debug" datei          # invertieren: Zeilen OHNE Treffer
grep -n "warn" datei           # Zeilennummern ausgeben
grep -c "success" datei        # nur Anzahl zählen
grep -l "passwort" *.conf      # nur Dateinamen ausgeben
grep -E "foo|bar" datei        # erweiterte Regex (egrep)

Mit Pipes kombinieren

ps aux | grep ssh              # Prozesse filtern
history | grep "git commit"    # in der Historie suchen
tail -f app.log | grep "ERROR" # Logs live filtern

Praxis-Tipps

• grep -i spart Zeit, wenn die Groß-/Kleinschreibung egal ist.
• Für ganze Wörter: grep -w wort, für echte reguläre Ausdrücke grep -E.
• Alternativen je nach Kontext: rg (ripgrep, schneller) und ag (The Silver Searcher).

Verwandte Grundlagen: Bash-Befehle und Regex.