# Notizen zum Programmierstil

von Dietrich Clauß <dietrich@Clauss-IT.com>, Stand: April 2020

- Schreibe kleine Funktionen (oder Prozeduren oder Methoden oder wie
  dieses Strukturelement in der jeweiligen Sprache nun gerade heißt).
  Eine Funktion soll genau eine Aufgabe erledigen und diese ordentlich.
- Zu Beginn einer Funktion die Werkzeuge zurechtlegen.  Parameter
  bekommen kurze, griffige Namen.  Benötigte globale Variablen werden
  auf lokale zugewiesen, ggf. werden Pointer benutzt.
- Lokale Variablen erhalten kurze Namen.  Die Bedeutung ist aus dem Code
  ersichtlich.  Wenn nicht, Code verbessern.
- im Funktionskörper nur Zugriff auf lokale Variablen und Parameter mit
  ihren kurzen Namen
  - dadurch automatisch kompakter Code, ohne daß die Lesbarkeit darunter
    leidet
- Schreibe "kugelsichere" Funktionen.  Alle Fehlerfälle abprüfen und
  Fehlercode zurückgeben, `assert()` benutzen bzw. Exceptions werfen.
  - So gestaltete Funktionen lassen sich nicht nur bestens debuggen,
    sondern auch gut lesen.
- Benutze Wächter-Style.  Erst Fehlerfälle ausschließen, dann die
  eigentliche Arbeit beginnen.
  - skaliert gut, besonders bei vielen unterschiedlichen
    Abbruchbedingungen
  - führt automatisch zu weniger Einrückungen
- Mehrere `return` in einer Funktion sind grundsätzlich in Ordnung.
  Ein `return` mitten im Funktionskörper ist nicht optimal, aber immer
  noch besser, als dort einen langen `if`-Block zu beginnen.  Im
  Idealfall die Funktion an dieser Stelle aufteilen, dann landet das
  `return` automatisch wieder als Wächter am Anfang der 2. Teilfunktion.
- `if..else` vermeiden.  Meist ist einer der Blöcke kurz und läßt sich in
  einem Wächter abhandeln.  Wenn `if..else` doch erforderlich ist, die
  Blöcke möglichst kurz halten, ggf. in weitere Funktionen auslagern.
- Kommentare nur an den Schnittstellen (Funktionsdeklaration).  Wenn das
  nicht reicht, den Code in mehrere Funktionen aufteilen.
- Kommentiere nur, was gemacht wird, nicht wie.  Das "wie" muß aus dem
  Code ersichtlich sein.  Wenn nicht, Code verbessern.
- Globale Variablen erhalten aussagekräftige Namen, mit Präfixen und
  allem drum und dran.  Die Länge des Namens spielt keine Rolle.
- Eingerückt wird mit Tabulatoren, und nur damit.  Ein Tab hat 8
  Zeichen.  Eine Zeile ist max. 80 Zeichen lang.  Wenn das nicht reicht,
  dann ist die Funktion zu groß, hat zuviele Einrück-Levels, zu lange
  lokale Variablennamen o.ä.  Ursache finden und Code verbessern.

## Beispielfunktion

	// Kommentar:  Funktionszweck, Parameter, Returnwerte,
	// Fehlercodes
	int some_function(int *a) {
		int b = some_global_variable;
		int *v = &some_other_global_stuff;
		int x;

		assert(a);
		if (b < 0)
			return -1;
		if (*v > 10)
			return -2;

		x = call_something(v, *a);
		if (x > 100)
			do_something();
		if (x > 90)
			do_something_other();
		return x;
	}

## Beispiel für Wächter-Style

falsch:

	int r;
	if (a_richtig) {
		if (b_richtig) {
			muh();
			maeh();
			r = sowieso();
		} else {
			r = Fehler_b;
		}
	} else {
		r = Fehler_a;
	}
	return r;

richtig:

	if (a_falsch)
		return Fehler_a;
	if (b_falsch)
		return Fehler_b;
	muh();
	maeh();
	return sowieso();