Eine redundante Geschichte der Programmierung: Von Parnas bis Scala

Andersartige Konzepte

Meilensteinen in der Entwicklung der Programmiersprachen, die nicht unserem eigentlichen Artikelthema Redundanzvermeidung dienen, sei an dieser Stelle kurz Tribut gezollt:

  • Die Robustheit von Programmen wurde gesteigert durch das Deklarationsprinzip (Algol 58), durch die Lokalität mittels des Blockprinzips (Algol 58) und der späten Deklaration von Variablen erst bei der ersten Verwendung (C++, 1983), durch das Einfrieren von errechneten Werten (C++) und durch Garbage Collection (LISP, 1958).
  • Die arbeitsteilige Entwicklung wurde gesteigert durch die Technik der getrennten Kompilation in Verbindung mit einem Linker (Fortran, Cobol).
  • Die Schreibbequemlichkeit wurde gesteigert durch dynamisch typisierte Sprachen beziehungsweise das Konzept der statischen Typinferenz (Scala 2003).
  • Die Verständlichkeit wurde gesteigert durch Kommentare beginnend vom Ganzzeilenkommentar in Fortran mit C, Mehrzeilenkommentar in Algol mit comment bis ;, Blockkommentar in Pascal mit { bis }, Restzeilenkommentar in Ada mit –, Dokukommentar in Java mit /** bis hin zu verschachtelten Blockkommentaren in Scala. Ebenfalls zur Verständlichkeit trugen lange Bezeichner bei (Cobol).
Zusammenfassung

Wenn man sieht, wie mühsam die Fortschritte der Programmierung in den letzten 50 Jahren waren, weiß man den heutigen Stand der Technik besser zu würdigen. Interessanter ist es aber noch, die treibende Kraft dahinter zu erkennen. Regelmäßig waren es hohe Redundanzen im Quellcode, die nach neuen Programmierkonstrukten verlangten. Meistens wurde die Möglichkeit eingeführt, dem redundanten Codemuster einen freigewählten Namen zu geben und diesen parametriert an mehreren Stellen aufzurufen: zum Beispiel bei Adressen, Konstanten, Unterprogrammen und Klassen. Manchmal ging die Entwicklung nicht ganz so weit und die redundanten Codemuster erhielten nur eigene Schlüsselwörter: zum Beispiel bei Formelübersetzungen, Schleifen, Verzweigungen und Ausnahmebehandlung. Die in Teil 1 und 2 vorgestellten Konzepte sind anhand verbreiteter Programmiersprachen besprochen worden (Tabelle 2). Oft wurden sie davor jedoch in Forschungssprachen wie Simula-67 oder LISP-Dialekten ausprobiert. Wenn eine Programmiersprache Redundanzen besser als eine Konkurrenzsprache beseitigen konnte, war das ein wesentlicher Pluspunkt im Kampf um Verbreitung. Es ist anzunehmen, dass das auch in Zukunft gilt.

Tabelle 2: Besprochene Programmiersprachen

Name Jahr Neuerungen
Freiburger Code > 1958 Programmierung der Z22
FORTRAN 1957 Formelübersetzung, FORTRAN II: Unterprogramme, Linker
ALGOL 1958 Unterprogramme, Blockprinzip, BNF, Steuerstrukturen, Rekursion
LISP 1958 Garbage Collection, Rekursion, funktionale Programmierung (FP)
Cobol 1959 Record-Variablen, lange Bezeichner
Pascal 1970 Record-Typ, Zeigertyp, strukturierte Programmierung
Smalltalk 1972 Verbreitung der objektorientierten Programmierung (OOP)
C 1973 Präprozessor, sizeof, Betriebssystem-API, Information Hiding, break
Modula-2 1978 Trennung Interface/Implementierung, if…end
Ada 1980 Generizität, Ausnahmebehandlung
C++ 1983 Statisch typsichere OOP, Einfrieren berechneter Werte, späte Deklaration
Java 1995 Statisch typsichere OOP mit Garbage Collection, API zur Stack-Trace-Ausgabe
AspectJ 2001 Zentralisierte Lösung von Querschnittsbelangen
Scala 2003 Statisch typsichere Synthese von OOP und FP
Christoph Knabe lernte als Schüler auf einer ausrangierten Zuse 22 das Programmieren, studierte ab 1972 Informatik, arbeitete ab 1981 als Softwareentwickler bei PSI und ist seit 1990 Professor für Softwaretechnik an der Beuth-Hochschule Berlin, vormals TFH. Scala ist seine 14. Sprache, in der er viel programmiert hat.
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.