---------------------------------------------------------------------------
Echte Programmierer meiden Pascal
---------------------------------------------------------------------------

Übersicht :

  * Kapitel 1 : Von Echten Männern
  * Kapitel 2 : Woran erkennt man Echte Programmierer?
  * Kapitel 3 : Strukturierte Programmierung
  * Kapitel 4 : Datenstrukturen
  * Kapitel 5 : Betriebssysteme
  * Kapitel 6 : Programmierwerkzeuge
  * Kapitel 7 : Wo findet man Echte Programmierer?
  * Kapitel 8 : Woran erkennt man Echte Programmierer?
  * Kapitel 9 : Wo funktioniert der Echte Programmierer am Besten?
  * Kapitel 10 : Aussichten

---------------------------------------------------------------------------

Kapitel 1 : Von Echten Männern


Vor langer Zeit, in der goldenen Ära der Computer, war es noch einfach, die
Männer von den Memmen zu trennen (mitunter auch "Echte Männer" und
"Müsli-Fresser" genannt). Echte Männer programmieren Computer, und
Müsli-Fresser ließen es bleiben.

Ein echter Computerprogrammierer sagte Dinge wie "DO 10 I=1,10" oder
"ABEND", und der Rest der Welt quengelte "Computer sind mir zu kompliziert"
oder "Ich kann zu Computern keine gefühlsmäßige Bindung aufbauen - sie sind
so unpersönlich". Dabei zeigte schon Remy Eyssen's Buch "Echte Männer mögen
kein Müsli" (Heyne TB 6290), daß Echte Männer zu nichts und niemanden eine
"gefühlsmäßige Bindung" aufbauen, und daß sie auch keine Angst haben,
unpersönlich zu sein.

Aber die Zeiten ändern sich. Heute stehen wir einer Welt gegenüber, in der
kleine alte Damen vollcomputerisierte Mikrowellenherde kaufen können, in
der 12 Jahre alte Dreikäsehochs gestandene Männer bei ASTEROID und PACMAN
sattmachen, und in der jeder seinen eigenen Heimcomputer kaufen und sogar
verstehen kann. Der Echte Programmierer ist gefährdet, von Studenten mit
einem igITT 2020 (deutsche Version des ABFALL-II) im Gepäck ersetzt zu
werden.

Es gibt allerdings einige Unterschiede zwischen dem typischen
PACMAN-spielenden Gymnasiasten und einem Echten Programmierer. Die Kenntnis
dieser Unterschiede wird den Heranwachsenden ein Ziel geben, nach dem sie
streben können - ein Vorbild, eine Vaterfigur. Ausserdem schützt sie den
echten Programmierer vor der Arbeitslosigkeit.

---------------------------------------------------------------------------

Kapitel 2 : Woran erkennt man Echte Programmierer ?


Der einfachste Weg, um einen Echten Programmierer zu erkennen, führt über
die von ihm benutzte Programmiersprache. Echte Programmierer benutzen
FORTRAN. Müsli-Fresser benutzen PASCAL. Nicolaus Wirth, der Schöpfer von
Pascal, wurde einmal gefragt, wie man seinen Namen ausspreche. "You can
either call me by name, pronouncing it 'Veert', or call me by value,
'worth'", antwortete er. Diese Bemerkung zeigt sofort, daß Wirth ein
Müsli-Fresser ist. Der einzige Parameter-Übergabe-Mechanismus, den Echte
Programmierer akzeptieren, ist call-by-value-return (call-by-result), wie
er in den IBM/370 FORTRAN-G und -H-Compilern implementiert ist. Echte
Programmierer brauchen schließlich keine abstrakten Konzepte, um ihre
Arbeit zu erledigen; sie sind vollkommen glücklich mit einem
Lochkartenstanzer, einem FORTRAN-IV-Compiler und einem Bier. Echte
Programmierer erledigen Listenverarbeitung, Zeichenketten-Manipulation,
Abrechnungswesen (wenn überhaupt) und künstliche Intelligenz in FORTRAN.
Was sie mit FORTRAN nicht machen können, machen sie mit Assembler, was sie
mit Assembler nicht machen können, lassen sie verächtlich liegen.

Akademische Computerspezialisten sind in den letzten Jahren aufs
Abstellgleis der strukturierten Programmierung geraten. Sie behaupten, daß
Programme verständlicher werden, wenn bestimmte Sprachkonstrukte und
Programmiertechniken benutzt werden. Sie können sich natürlich nicht
einigen, welche Konstrukte am besten geeignet sind, und die Beispiele, an
denen sie ihre speziellen Standpunkte aufzeigen wollen, passen ausnahmslos
auf eine einzige Seite irgend eines obskuren Journals. Als ich aus der
Schule kam, dachte ich, ich sei der Programmierer der Welt. Ich konnte ein
unschlagbares TIC-TAC-TOE-Spiel (Vier-in-einer-Reihe) schreiben,
beherrschte 5 verschiedene Programmiersprachen und schrieb fehlerfreie
1000-Zeilen-Programme. Dann kam ich in die Wirklichkeit.

Meine erste Aufgabe bestand darin, ein 200000-Zeilen-FORTRAN-Programm zu
lesen, zu verstehen und um den Faktor 2 zu beschleunigen. Jeder Echte
Programmierer wird einem versichern, daß die gesamte strukturierte
Programmierung der Welt in einem solchen Fall nicht hilft - hier braucht
man wirklich Talent.

---------------------------------------------------------------------------

Kapitel 3 : Strukturierte Programmierung


Einige Beobachtungen zum Thema "Echte Programmierer und Strukturierte
Programmierung":

  * Echte Programmierer haben keine Angst vor GOTO's.
  * Echte Programmierer schreiben 5 Seiten lange DO-Schleifen, ohne
    durcheinander zu geraten.
  * Echte Programmierer lieben das arithmetische IF-Statement (das mit den
    3 Ausgängen), weil sie den Code interessanter machen.
  * Echte Programmierer schreiben selbstmodifizierende Programme, speziell
    wenn sie damit in einer kleinen Schleife 20 Nanosekunden einsparen
    können.
  * Echte Programmierer brauchen keine Kommentare, das Programm ist
    selbstdokumentierend.
  * Da FORTRAN strukturierte IF-, REPEAT-UNTIL- oder CASE- Anweisungen
    nicht kennt, braucht sich der Echte Programmierer nicht zu sorgen, daß
    er sie nicht benutzt. Außerdem kann man nötigenfalls über "Assigned
    GOTO's' (Zuweisung eines Sprung- Labels auf eine Variable) simulieren.

---------------------------------------------------------------------------

Kapitel 4 : Datenstrukturen


Auch Datenstrukturen waren in letzter Zeit in der Diskussion. Abstrakte
Datentypen, Records, Pointer, Listen und Zeichenketten sind in gewissen
Kreisen populär geworden. Wirth, der Müsli-Fresser, verfaßte sogar ein
ganzes Buch ("Algorithmen und Datenstrukturen") in dem er behauptete, daß
man Programme schreiben könne, die auf Datenstrukturen aufbauen, statt es
umgekehrt zu machen. Wie jeder Echte Programmierer weiß, gibt es nur eine
wirklich nützliche Datenstruktur, das Array. Zeichenketten, Listen, Records
und Mengen sind allesamt Sonderfälle von Arrays und können auch so
behandelt werden, ohne dadurch die Sprache zu verkomplizieren. Das
Schlimmste an den ganzen schönen Typen ist außerdem, daß man sie
deklarieren muß, während Echte Programmiersprachen, wie man weiß, den Typ
anhand des ersten Buchstabens eines maximal 6 Zeichen langen Bezeichners
implizit festlegen.

---------------------------------------------------------------------------

Kapitel 5 : Betriebssysteme


elches Betriebssystem der Echte Programmierer benutzt ? CP/M ? Gott
bewahre! Das ist doch im Grunde ein Spielzeug-Betriebssystem. Selbst kleine
alte Damen und Hauptschüler können CP/M benutzen und verstehen.

NIX ist natürlich schon viel komplizierter - der typische UNIX- Hacker
weiß nie, wie das PRINT-Kommando diese Woche heißt - aber wenn man es genau
nimmt, ist UNIX auch nur ein verherrlichtes Telespiel. Niemand arbeitet auf
UNIX-Systemen an ernsthaften Dingen - man schickt kleine Witzchen über das
USENET rund um die Welt oder schreibt ein neues Adventure-Spiel oder

Forschungsberichte.

Nein, der Echte Programmierer benutzt OS/370. Ein guter Programmierer kann
die Beschreibung des Fehlers Ijk305i in seinem JCL-Manual (Job Control
Language, BATCH-Kommandosprache) finden und verstehen. Ein großartiger
Programmierer kann JCL schreiben, ohne je ein Manual zu sehen. Ein wahrhaft
guter Programmierer kann Fehler in einem 6-Megabyte-Hexdump finden, ohne
einen Taschenrechner zu benutzen.

OS/370 ist wirklich ein bemerkenswertes Betriebssystem. Mit einem einzigen
falsch plazierten Leerzeichen kann man die gesamte Arbeit mehrerer Tage
zerstören, was die Wachsamkeit im Programmierteam ungemein fördert. Der
beste Weg zum System ist der Kartenstanzer. Zwar behaupten einige Leute, es
gäbe ein Timesharing System unter OS/370, aber nach sorgfältigen
Nachforschungen bin ich zu dem Schluß gekommen, daß sie sich irren.

---------------------------------------------------------------------------

Kapitel 6 : Programmierwerkzeuge


Welche Werkzeuge ein Echter Programmierer benutzt? Nun, theoretisch könnte
er seine Programme über die Maschinenkonsole eingeben und laufenlassen. In
den frühen Tagen der Computerei, als Computer noch Maschinenkonsolen
hatten, wurde dies auch gelegentlich getan. Der typische Programmierer
wußte den System-Urlader Bit für Bit auswendig und tastete ihn ein, sobald
er von seinem Programm zerstört worden war. Damals war Speicher auch noch
Speicher - der war nicht einfach leer, wenn der Strom ausfiel.
Hauptspeicher von heute hingegen vergessen entweder Dinge, die sie behalten
sollten, oder halten Informationen, die schon lange weg sein sollten. Aber
zurück zum Thema. Die Legende sagt, daß Seymour Cray, der Erfinder des
Cray-I Supercomputers und der meisten anderen Rechner von Control Data,
selbst das erste Betriebssystem für die CDC 7600 an der Maschinenkonsole
eingetastet hat, als sie das erste Mal eingeschaltet wurde. Cray ist
selbstverständlich ein Echter Programmierer.

Einen der Echten Programmierer, die ich am meisten bewundere, arbeitete als
Systemprogrammierer für Texas Instruments. Eines Tages erhielt er ein
Ferngespräch von einem Benutzer, dessen System inmitten einer wichtigen
Arbeit abgestürzt war. Der Typ reparierte dann den Schaden übers Telefon.
Er brachte den Benutzer dazu, an der Maschinenkonsole
Disk-I/O-Instruktionen einzutasten, Systemtabellen in Hexadezimal zu
reparieren und Registerinhalte übers Telefon durchzugeben. Die Moral von
der Geschichte: Obwohl ein Echter Programmierer normalerweise Kartenlocher
und Schnelldrucker benutzt, kommt er im Notfall auch mit Maschinenkonsole
und Telefon aus.

---------------------------------------------------------------------------

In einigen Firmen besteht die Programmeingabe allerdings nicht mehr aus 10
schlangestehenden Ingenieuren, die auf einen 029-Locher warten. In meiner
Firma zum Beispiel steht kein einziger Kartenlocher. Der echte
Programmierer muß in diesem Fall seine Arbeit mit einem Texteditor
erledigen. Auf den meisten Rechnern stehen verschiedene Editoren zur
Verfügung, und der Echte Programmierer muß aufpaßen, daß er einen erwischt,
der seinen persönlichen Stil wiedergibt. Viele Leute glauben, daß die
besten Editoren der Welt am Xerox Palo Alto Research Center geschrieben
wurden und auf Altos- und Dorado-Computern laufen. Unglücklicherweise würde
jedoch kein Echter Programmierer einen Computer mit einem Betriebssystem
benutzen, das SmallTalk heißt, und sicherlich auch nicht über eine Maus mit
dem Rechner kommunizieren.

Einige Konzepte der Xerox-Editoren sind mittlerweile in Editoren
eingeflossen, die unter sinnvoller benannten Betriebssystemen arbeiten, so
wie EMACS und VI. Das Problem mit diesen Editoren ist, daß Echte
Programmierer das Konzept des "Du kriegst, was Du siehst" für schlecht
halten. Der Echte Programmierer will einen "Du hast es so gewollt, da hast
Du's"-Editor, einen der kompliziert ist, kryptisch, leistungsfähig,
gnadenlos und gefährlich. TECO, um genau zu sein.

So wurde beobachtet, daß TECO-Kommandofolgen dem Leitungsrauschen ähnlicher
sind als lesbarer Text. Eins der unterhaltsameren Spiele, die mit TECO
möglich sind, besteht darin, den eigenen Namen als Kommando einzugeben und
zu raten, was dann passiert. So ungefähr jeder mögliche Tippfehler kann
dank TECO das gerade editierte Programm zerstören, oder schlimmer noch,
kann kleine mysteriöse Fehler in erstmals funktionierende Unterprogramme
einbringen.

Aus diesem Grund editieren Echte Programmierer nur sehr widerwillig
Programme, die schon fast laufen. Sie finden es viel einfacher, den binären
Objektcode direkt zu ändern, für gewöhnlich mit einem wundervollen
Programm, das SUPERZAP heißt (auf Nicht-IBM- Rechnern entsprechend anders).
Dies funktioniert so gut, daß viele laufende Programme auf IBM-Systemen
keine Ähnlichkeit mit den ursprünglichen FORTRAN-Quellprogrammen haben. In
einigen Fällen ist nicht einmal mehr das Quellprogramm vorhanden. Wenn dann
der Zeitpunkt gekommen ist, so ein Programm zu ändern, würde kein Manager
auch nur daran denken, einem geringeren als einem Echten Programmierer
diese Arbeit zu übertragen - kein Müsli-fressender strukturierter
Programmierer wüßte auch nur, wo er mit der Arbeit anfangen soll. Man nennt
das Arbeitssicherungsmaßnahme.

---------------------------------------------------------------------------

Hier eine Liste der wichtigsten Programmierhilfen, die der Echte
Programmierer nicht benutzt:

  * FORTRAN-Präprozessoren wie MORTRAN oder RATFOR. Diese Haute Cuisine
     der Programmierung eignet sich hervorragend, um Müsli zu produzieren.
     Quellcodeorientierte Debugger. Echte Programmierer lesen Hexdumps.
  * Compiler, die Code für Array-Indexprüfungen zur Laufzeit erzeugen. Sie
     ersticken jede Kreativität, zerstören die meisten der interessantesten
     Anwendungen der EQUIVALENCE- Vereinbarung, und machen Änderungen des
     Betriebssystems mit Hilfe negativer Indizes unmöglich. Und schlimmer
     noch, solcher Code ist ineffizient.
  * Programm-Pflege-Systeme. Ein Echter Programmierer hält seine Software
     als Kartonstapel unter Verschluß, denn dies zeigt, daß der Besitzer
     seine wichtigen Programme nicht unbewacht lassen kann.

---------------------------------------------------------------------------

Kapitel 7 : Wo findet man Echte Programmierer?


Wo der Echte Programmierer arbeitet? Welche Art von Programmen derart
talentierter Individuen würdig ist? Nun, man kann sicher sein, daß man nie
einen Echten Programmierer beim Schreiben von Buchhaltungsprogrammen in
COBOL erwischen wird, oder gar beim Sortieren von Abonnentenadressen des
SPIEGEL's. Nein, ein Echter Programmierer braucht Aufgaben von
weltbewegender Bedeutung. Echte Programmierer arbeiten für das Los Almaos
National Laboratory und schreiben dort Atomkriegs Simulationen auf CRAY-I
Supercomputern, oder sie arbeiten bei der National Security Agency und
entschlüsseln russische Funksprüche. Nur weil tausende Echte Programmierer
für die NASA gearbeitet haben, waren "unsere Jungs" eher auf dem Mond als
die Kosmonauten. Die Computer im Space Shuttle wurden von Echten
Programmierern programmiert und auch die Betriebssysteme der Cruise
Missiles der Firma BOEING wurden von diesen Echten Programmierern
entworfen.

Einige der Ehrfurchteinflössendsten Echten Programmierer arbeiten in dem
Propulsion Laboratory in Kalifornien. Viele von Ihnen kennen das gesamte
Betriebssystem der Pioneer- und Voyager-Sonden auswendig. Mit einer
Kombination aus großen, bodengebundenen FORTRAN-Programmen und kleinen, von
den Sonden mitgeführten Assemblerprogrammen vollbringen sie unglaubliche
Kunststücke der Navigation und Improvisation. So treffen sie nur 10
Kilometer große Fenster nahe Saturn nach 6 Jahren Flug durch den Weltraum,
oder reparieren bzw. umgehen defekte Sensoren, Sender oder Batterien.
Angeblich soll es einem Echten Programmierer sogar gelungen sein, in ein
paar hundert Byte unbenutzten Speichers innerhalb der Voyager-Sonde ein
Mustererkennungsprogramm zu pressen, das einen neuenn Mond des Jupiters
suchte, fand und photographierte.

Für die Galileo-Sonde ist vorgesehen, daß sie auf ihrem Weg zum Jupiter
entlang einer schwerkraftgelenkten Bahn um den Mars vorbeizieht. Diese Bahn
führt in einer Entfernung von 80 +/- 3 km an der Marsoberfläche vorbei.
Kein Mensch würde diese Art der Navigation einem Pascal-Programm oder gar
Programmierern anvertrauen.

Viele der echten Programmierer dieser Welt arbeiten für die amerikanische
Regierung, meist für das Verteidigungsministerium. So soll es sein. In
letzter Zeit allerdings erscheinen dunkle Wolken am Horizont der Echten
Programmierer. Es scheint, als hätten einige einflußreiche Müsli-Fresser im
Verteidigungsministerium entschieden, daß in Zukunft alle
Verteidigungsprogramme in so einer Art von großer, vereinheitlichter
Programmiersprache namens ADA geschrieben werden müßten. Lange Zeit schien
es, als läge ADA's Bestimmung im Verstoß gegen alle Regeln der Echten
Programmierung. Es ist eine Sprache mit Strukturen, Datentypen, strenger
Typenbindung und Semikolons. Kurz, sie ist wie geschaffen um die
Kreativität des typischen Echten Programmierers zu verkrüppeln.

Glücklicherweise hat die jetzt von DoD ausgewählte Sprache noch genügend
interessante Eigenschaften, um dem Echten Programmierer eine Annäherung zu
ermöglichen: Sie ist unglaublich komplex, sie enthält Möglichkeiten, um mit
dem Betriebssystem herumzumachen und Speicherbereiche neu zu verteilen, und
Edgar Dijkstra mag sie nicht. Dijkstra ist, wie man wissen sollte, der
Autor von "GOTO's Considered Harmful", einem Meilenstein der
Programmiermethologie, der von Pascal-Programmierern und Müsli-Fressern
gleichermaßen bewundert wird. Und außerdem, ein zu allem entschlossener
Echter Programmierer kann in jeder Sprache FORTRAN Programme schreiben.

Der Echte Programmierer kann allerdings auch Kompromisse in Bezug auf seine
Prinzipien machen und an etwas geringeren Aufgaben als der Vernichtung des
Lebens arbeiten, sofern er dafür entsprechend bezahlt wird. Viele Echte
Programmierer schreiben z.B. Videospiele für ATARI, allerdings spielen sie
nicht damit. Ein Echter Programmierer weiß, wie er die Maschine jedesmal
schlagen kann, und damit ist es keine Herausforderung mehr. Jeder bei
Lucas-Film ist ein Echter Programmierer, denn es wäre verrückt, das Geld
von 50 Millionen STAR_WARS-Fans auszuschlagen.

Der Anteil der Echten Programmierer im Bereich der Computer- Grafik ist
etwas geringer als anderswo, was wahrscheinlich daran liegt, daß noch
niemand irgendeinen Nutzen der Computer-Grafik entdeckt hat. Andererseits
werden Computer-Graphics überwiegend in FORTRAN abgehandelt, daher gibt es
einige Leute, die so das Schreiben von COBOL-Programmen vermeiden.

---------------------------------------------------------------------------

Kapitel 8 : Woran erkennt man Echte Programmierer?


Im Allgemeinen spielt der Echte Programmierer wie er arbeitet - mit
Computern. Er ist ständig darüber erheitert, daß sein Arbeitgeber ihn
tatsächlich für etwas bezahlt, was er nur so zum Spaß sowieso tun würde -
allerdings achtet er darauf, diese Meinung nicht zu laut zu äußern.
Gelegentlich kommt der Echte Programmierer auch aus seinem Büro heraus, um
sich ein wenig frische Luft und ein oder zwei Bierchen zu genehmigen. Hier
daher einige Hinweise, wie man den Echten Programmierer außerhalb des
Computerraums erkennt:

  * Auf Parties stehen Echte Programmierer in einer Ecke und diskutieren
     über Sicherheitsmechanismen von Betriebssystemen und wie man daran
     herumprogrammiert. Bei Fußballspielen vergleicht der Echte
     Programmierer die Ergebnisse mit seinen auf grünlichem
     Leporello-Papier gedruckten Computer-Simulationsergebnissen.
  * Am Strand zeichnet der Echte Programmierer Flußdiagramme in den Sand.
  * Ein Echter Programmierer geht in die Disco um sich die Lichtorgel
     anzusehen.
  * Bei Begräbnissen sagt der Echte Programmierer typischerweise "Armer
     Hans-Helmut. Er war mit seinem Sortierprogramm schon fast fertig, als
     ihn der Herzinfarkt erwischt hat".
  * Im Supermarkt besteht der Echte Programmierer darauf, seine Bierdosen
     selber über das Fenster des Strichcodelesers zu schieben, weil er
     keinem Kassierer zutraut, dies beim ersten Versuch richtig zu machen.

---------------------------------------------------------------------------

Kapitel 9 : In welcher Umgebung funktioniert der Echte Programmierer am Besten?


Nun, dies ist eine sehr wichtige Frage für Manager von Echten
Programmierern. Wenn man bemerkt, wie teuer es ist, einen von ihnen im
Betrieb zu halten, dann sollte man ihn oder sie in eine optimale
Arbeitsumgebung setzen.

Der typische Echte Programmierer lebt vor einem Computerterminal. Rund um
dieses Terminal liegen Ausdrucke von jedem Programm, an dem er je
gearbeitet hat, sie stapeln sich grob chronologisch geordnet auf jeder
ebenen Fläche des Büros. Im Zimmer verteilt finden sich über ein Dutzend
mit kaltem Kaffee mehr oder weniger gefüllter Tassen. Gelegentlich
schwimmen Zigarettenkippen darin herum, in einigen Fällen auch Reste von
Orangenschalen. Irgendwo liegen Kopien des OS JCL-Manuals und der
"Principles of Operation" an besonders interessanten Stellen aufgeschlagen
herum, außer bei extrem guten Leuten. An der Wand klebt ein
Schnelldruckerkalender mit Snoopy aus dem Jahr 1969. Über den Boden
verteilt liegen Reste der Verpackungen von gefüllten Keksen (der Typ, der
schon in der Fabrik furztrocken gebacken wird, daß er auch bei längerem
Liegen im Automaten nicht schlecht wird). Schließlich, in der linken,
oberen Schublade des Schreibtisches, unter der Schachtel mit den
Muntermachern, liegt eine Schablone für Flußdiagramme, die sein Vorgänger
dort vergessen hat. Echte Programmierer schreiben Programme und keine
Dokumentationen, das überlässt man den Typen von der Wartung.

Der Echte Programmierer ist in der Lage, 30, 40, ja sogar 50 Stunden in
einem Rutsch zu arbeiten, und das unter hohem Zeitdruck. Genau genommen mag
er es so am liebsten. Schlechte Antwortzeiten regen den Echten
Programmierer nicht auf - sie geben ihm die Chance, zwischen zwei Kommandos
ein bißchen Schlaf zu ergattern. Wenn die Planung nicht genug Zeitdruck
bereithält, dann tendiert der Echte Programmierer dazu, seine Arbeit
herausfordernder zu machen, indem er sich die ersten neun Wochen mit einem
kleinen, aber sehr interessanten Teil des Problems befaßt, um dann in der
letzten Woche seine Aufgabe in zwei oder drei 50 Stunden Marathonsitzungen
zu beenden. Dies beeindruckt nicht nur den Manager, sondern schafft
gleichzeitig eine hervorragende Entschuldigung für das Fehlen der
Dokumentation.

Und überhaupt: Kein Echter Progammierer arbeitet von 9 bis 5, außer denen
von der Nachtschicht. Echte Programmierer tragen keine Schlipse. Echte
Programmierer tragen keine hochhackigen Schuhe. Echte Programmierer kommen
zur Arbeit, wenn andere zum Mittagessen gehen. Ein Echter Programmierer
vergißt vielleicht den Vornamen seiner Angetrauten, aber niemals den Inhalt
der gesamten ASCII- (oder EBCDIC-) Tabelle. Echte Programmierer können
nicht kochen. Da Supermärkte selten um 3 Uhr morgens geöffnet sind, müssen
sie sowieso von Kaffee und Keksen leben.

---------------------------------------------------------------------------

Kapitel 10 : Aussichten


Die Zukunft betrachtend machen sich eine Reihe von Echten Programmierern
Sorgen, daß die jüngste Programmierergeneration nicht mehr mit der gleichen
Lebensperspektive aufwächst wie sie selbst. Viele der jüngeren haben noch
nie einen Computer mit einer Maschinenkonsole gesehen. Kaum ein
Schulabgänger kann heute noch hexadezimal rechnen, ohne einen
Taschenrechner zu benützen. Die Studenten von heute sind weich - geschützt
von den Realitäten der Programmierung durch symbolische Debugger,
Texteditoren, die Klammern zählen und benutzerfreundlichen
Betriebssystemen. Und das schlimmste ist, einige dieser angeblichen
Computer-Spezialisten kommen zu Rang und Namen...

---------------------------------------------------------------------------