Computergeschichte(n) – nicht nur fur Geeks: Von Antikythera zur Cloud

H. R. Wieland Computergeschichte(n) – nicht nur für Geeks Von Antikythera zur Cloud Der Name Galileo Press geht auf ...

Author: H.R. Wieland

304 downloads 3351 Views 15MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

H. R. Wieland

Computergeschichte(n) – nicht nur für Geeks Von Antikythera zur Cloud

Der Name Galileo Press geht auf den italienischen Mathematiker und Philosophen Galileo Galilei (1564–1642) zurück. Er gilt als Gründungsfigur der neuzeitlichen Wissenschaft und wurde berühmt als Verfechter des modernen, heliozentrischen Weltbilds. Legendär ist sein Ausspruch Eppur si muove (Und sie bewegt sich doch). Das Emblem von Galileo Press ist der Jupiter, umkreist von den vier Galileischen Monden. Galilei entdeckte die nach ihm benannten Monde 1610. Lektorat Judith-Lemoine Stevens, Anne Scheibe Korrektorat Marlis Appel, Troisdorf Cover Barbara Thoben, Köln Coverfotos Die Coverabbildungen sind aus dem Buch entnommen und enthalten dort die Quellhinweise der Rechteinhaber. Typografie und Layout Vera Brauner Herstellung Maxi Beithe Satz SatzPro, Krefeld Druck und Bindung Bercker Graphischer Betrieb, Kevelaer Dieses Buch wurde gesetzt aus der Linotype Syntax Serif (9,25/13,25 pt) in FrameMaker. Gedruckt wurde es auf chlorfrei gebleichtem Offsetpapier. Gerne stehen wir Ihnen mit Rat und Tat zur Seite: [email protected] bei Fragen und Anmerkungen zum Inhalt des Buches [email protected] für versandkostenfreie Bestellungen und Reklamationen [email protected] für Rezensions- und Schulungsexemplare Der Verlag hat sich intensiv um die Einholung aller Bildrechte bemüht. Leider konnten wir einige Rechteinhaber nicht ermitteln, einige andere nicht erreichen. Wir bitten diese Rechteinhaber, sich mit uns in Verbindung zusetzen. Berechtigte Ansprüche gelten wir selbstverständlich in angemessener Weise ab.

Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. ISBN

978-3-8362-1527-5

© Galileo Press, Bonn 2011 1. Auflage 2011 Das vorliegende Werk ist in all seinen Teilen urheberrechtlich geschützt. Alle Rechte vorbehalten, insbesondere das Recht der Übersetzung, des Vortrags, der Reproduktion, der Vervielfältigung auf fotomechanischem oder anderen Wegen und der Speicherung in elektronischen Medien. Ungeachtet der Sorgfalt, die auf die Erstellung von Text, Abbildungen und Programmen verwendet wurde, können weder Verlag noch Autor, Herausgeber oder Übersetzer für mögliche Fehler und deren Folgen eine juristische Verantwortung oder irgendeine Haftung übernehmen. Die in diesem Werk wiedergegebenen Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. können auch ohne besondere Kennzeichnung Marken sein und als solche den gesetzlichen Bestimmungen unterliegen.

Liebe Leserin, lieber Leser, haben Sie Ihre Koffer gepackt? – Nein? – Macht nichts, denn auf der Reise, zu der wir Sie einladen wollen, brauchen Sie nichts weiter als ein bisschen Zeit und viel Lust, Neues zu entdecken. Kommen Sie mit und erleben Sie eine spannende Zeitreise durch die Welt unserer Blechkollegen, von der Antike zurück in die Zukunft. H. R. Wieland hat tief in der Geschichte der Rechenmaschinen gegraben und viel Kurioses, Stauneswertes und schlicht Verblüffendes zu Tage gefördert. Hätten Sie z. B. gedacht, dass Alexander der Große den Sieg in seiner vielleicht wichtigsten Schlacht einer Rechenmaschine zu verdanken hat? Oder dass IBM einst ein Produkt herstellte, dass man eher in Uromas guter Stube als in einem Rechenzentrum erwartet? Lassen Sie sich überraschen, was die Geschichte der Rechenmaschinen vom antiken Mechanismus von Antikythera bis zum modernen Supercomputer an spannenden Episoden bereithält. Und da ohne die passende Software selbst Steve Jobs niemanden dazu bringen könnte, in aller Herrgottsfrühe vor dem Laden zu kampieren, um als Erster das brandneue Gerät aus dem Hause Apple in die Finger zu bekommen, finden Sie in diesem Buch auch einen Abriss der Geschichte der Computerprogramme. Angefangen bei Lady Adas erstem lauffähigen Programm verfolgen Sie die Entwicklung der Programmiersprachen, Betriebssysteme und der wichtigsten Programme überhaupt: der Spiele! Heiter bis wolkig wird es im letzten Teil des Buches: Hier werfen Sie einen Blick in die rasante Entwicklung der virtuellen Welten und begeben sich in die bislang nur teilweise erforschte Welt der zellulären Automaten. Hat Computerpionier Zuse Recht, und kann man das Universum als einen gigantischen Zellularautomaten betrachten?! Doch wo bliebe der Spaß, wenn Sie die alten Rechner, Spiele und Programme nur auf Fotos betrachten könnten? Deshalb finden Sie im gesamten Buch Anleitungen, wie Sie die gezeigten Beispiele selbst programmieren und alte Rechenmaschinen am heimischen PC simulieren können. Die benötigte Software finden Sie auf der beiliegenden DVD. Viel Spaß beim Stöbern, Entdecken und Programmieren!

Ihre Judith Stevens-Lemoine Lektorat Galileo Computing

[email protected] www.galileocomputing.de Galileo Press · Rheinwerkallee 4 · 53227 Bonn

Auf einen Blick TEIL I Geschichte der Hardware 1

Von Rosenkranz und Rechenschieber ...................................

23

2

Computer ohne Programme .................................................

49

3

Vom ersten Computer und anderen Rechnersauriern ............

97

4

Von Äpfeln und Brotkästen ..................................................

147

5

Der Superrechner im Wohnzimmer ......................................

189

TEIL II Geschichte der Software 6

Von Lady Ada bis F# ............................................................

237

7

Softwaregeschichte(n) ..........................................................

291

8

Von CP/M über DOS zu Windows ........................................

319

9

Computerspiele ....................................................................

351

10 Das Netz der Netze ..............................................................

421

TEIL III Die Zukunft 11 Virtualisierung ......................................................................

465

12 Mein PC is’ ene Wolke .........................................................

477

13 Denkmaschine .....................................................................

513

Inhalt Vorwort ........................................................................................................

15

TEIL I Geschichte der Hardware 1

Von Rosenkranz und Rechenschieber .......................................

23

1.1 1.2 1.3 1.4

Eins, zwei, drei ... .................................................................. Hexadezimal mit dem Windows Calculator ............................ Der heilige Computer aus gläsernen Perlen ............................ Von Seeschlachten und Zahlenschiebern ............................... 1.4.1 Rechenstäbe und Rechenschieber ............................. 1.4.2 Der Abakus ............................................................... Digital und analog ................................................................. 1.5.1 Uhrenvergleich ......................................................... 1.5.2 LP versus CD ............................................................. 1.5.3 Zwischen digital und analog und zwischen wahr und falsch ......................................... Lesen Sie weiter ....................................................................

23 28 30 32 33 37 39 39 41

Computer ohne Programme .......................................................

49

2.1

49 51 58 62 66 67 70 71 72

1.5

1.6

2

2.2 2.3

2.4

2.5

Die ersten Rechenmaschinen ................................................. 2.1.1 Die Maschine von Antikythera .................................. 2.1.2 Die Sterne lügen nicht .............................................. Planetarien simulieren mit Stellarium ..................................... Rechenuhr, Dampfrechner und Superautomaten ................... 2.3.1 Schickards Rechenmaschine ...................................... 2.3.2 Die Pascaline ............................................................ 2.3.3 Morlands Apparate ................................................... 2.3.4 Leibniz' Rechenmaschine .......................................... 2.3.5 Von Leibniz’ Zeit in die Gegenwart: Brunsviga, Superautomat und Co. .............................................. 2.3.6 Der Taschenrechner .................................................. Die Analytische Maschine ...................................................... 2.4.1 Babbages Idee .......................................................... 2.4.2 Analoge Computer .................................................... Noch mehr Spaß: Sonnenfinsternis simulieren ....................... 2.5.1 Eine deutsche Sonnenfinsternis .................................

45 47

76 78 80 80 85 87 87

5

Inhalt

2.5.2 Das erste Datum der Weltgeschichte ........................ 2.5.3 Ring of Fire ............................................................... Lesen Sie weiter ....................................................................

89 92 93

Vom ersten Computer und anderen Rechnersauriern ...........

97

2.6

3

3.1 3.2 3.3 3.4 3.5 3.6 3.7

4

4.3

4.4 4.5 4.6

Vom Rechensaurier zum Minicomputer ................................. Der Biss in den Apfel ............................................................. 4.2.1 Steve Jobs versus The Beatles .................................... 4.2.2 Der erste PC ............................................................. 4.2.3 Ein Tag im November ............................................... 4.2.4 Lisas trauriges Ende .................................................. Die Zeit der Homecomputer .................................................. 4.3.1 Mein Spectravideo .................................................... 4.3.2 Der C64 – der König der Heimcomputer ................... Der IBM-PC: besser spät als nie ............................................. Noch mehr Spaß: Atari, Amiga und Co. ................................. Lesen Sie weiter ....................................................................

147 153 154 156 158 160 161 161 168 179 181 185

Der Superrechner im Wohnzimmer .......................................... 189 5.1 5.2

5.3 5.4

5.5

6

97 106 110 118 119 125 144

Von Äpfeln und Brotkästen ........................................................ 147 4.1 4.2

5

Z wie Zuse ............................................................................. Die geheime Schlacht der Codeknacker ................................. ENIAC – im Dienste der Armee .............................................. UNIVAC – ein Computer schreibt Wahlgeschichte ................. Frei nach Turing: die Manchester Mark I ............................... Der Rechner geht in Serie: Innovation made by IBM .............. Lesen Sie weiter ....................................................................

Der PC erobert die Welt ........................................................ Mikroprozessoren .................................................................. 5.2.1 Die Entwicklung des Prozessors ................................ 5.2.2 Moderne Mikroprozessoren ...................................... Workstation Clons ................................................................. Vektor- und Parallelrechner ................................................... 5.4.1 Crays Erfindung ......................................................... 5.4.2 Aktuelle Entwicklung ................................................ Rechnende Netze .................................................................. 5.5.1 Computercluster ....................................................... 5.5.2 Computerschwärme retten die Welt .........................

189 192 193 197 202 203 203 208 211 211 216

Inhalt

5.6 5.7

5.5.3 Grid-Computing ........................................................ 5.5.4 Das SETI-Projekt ....................................................... 5.5.5 Die Zukunft der Supercomputer ................................ Noch mehr Spaß: Eigene Cray gefällig? .................................. Lesen Sie weiter ....................................................................

216 220 229 231 233

TEIL II Geschichte der Software 6

Von Lady Ada bis F# ..................................................................... 237 6.1

6.2

6.3

6.4

6.5

6.6

Das rasende Herz ................................................................... 6.1.1 Der Prozessor ........................................................... 6.1.2 In Kurzform: Assembler ............................................. 6.1.3 Die erste »höhere« Sprache: Fortran .......................... Die Turingmaschine ............................................................... 6.2.1 Aufbau und Funktionsweise einer Turingmaschine .... 6.2.2 Fleißige Biber und die Unvollständigkeit der Mathematik ........................................................ 6.2.3 Vollständig unvollständig .......................................... ALGOL und die GOTO-Programmierung ................................ 6.3.1 Compiler und Interpreter .......................................... 6.3.2 BASIC ....................................................................... 6.3.3 ALGOL ...................................................................... Mehr Sprachen, bitte! ........................................................... 6.4.1 Cobol und PL/1 ......................................................... 6.4.2 C .............................................................................. 6.4.3 Smalltalk ................................................................... 6.4.4 Pascal ....................................................................... 6.4.5 C++ .......................................................................... 6.4.6 Prolog ....................................................................... 6.4.7 Ada ........................................................................... 6.4.8 Python ...................................................................... 6.4.9 BASIC/VB .................................................................. 6.4.10 Ruby ......................................................................... 6.4.11 Java .......................................................................... Noch mehr Spaß: Ein Blick in Microsofts Forschungsabteilung .............................................................. 6.5.1 F# ............................................................................. 6.5.2 Microsoft Research (MSR) ......................................... Lesen Sie weiter ....................................................................

237 239 242 243 245 246 252 253 255 258 259 262 266 266 268 269 273 276 278 278 280 281 283 283 287 287 288 288

7

Inhalt

7

Softwaregeschichte(n) ................................................................. 291 7.1

7.2

7.3

7.4

7.5

8

8.2

8.3

8.4 8.5

8.6

Masterprogramme ................................................................. 8.1.1 Geschichtlicher Überblick ......................................... 8.1.2 Wie war das eigentlich mit DOS? .............................. Die Windows-Story ............................................................... 8.2.1 Das »Ur-Windows« ................................................... 8.2.2 NT – New Technology ............................................... 8.2.3 Das Millennium-Gespenst geht um ........................... Linux/Ubuntu ........................................................................ 8.3.1 Linux tritt auf den Plan ............................................. 8.3.2 Shuttleworths Geschenk an die Menschheit .............. 8.3.3 Der Mikrokernel ....................................................... Computern in Echtzeit ........................................................... Noch mehr Spaß: OS/2 und gOS ............................................ 8.5.1 OS/2 ......................................................................... 8.5.2 gOS .......................................................................... 8.5.3 Singularity – das Neueste aus dem MicrosoftLabor ........................................................................ Lesen Sie weiter ....................................................................

320 321 321 324 326 328 329 332 332 333 338 339 343 343 343 347 349

Computerspiele ............................................................................. 351 9.1 9.2

8

291 293 296 299 301 302 307 307 308 312 313 314 315 317

Von CP/M über DOS zu Windows ............................................ 319 8.1

9

Vom technischen Wunder zur Büromaschine ......................... 7.1.1 Software, die Nutzen bringt ...................................... 7.1.2 Das große Artensterben ............................................ Wie PowerPoint erfunden wurde ........................................... 7.2.1 Kennen Sie »Bob«? .................................................... 7.2.2 Ein Riese stolpert ...................................................... Es muss nicht immer Microsoft sein ....................................... 7.3.1 König der Datenbanken ............................................ 7.3.2 Ein Stern am Computerhimmel ................................. 7.3.3 Novell ....................................................................... Nicht umsonst, aber Open Source ......................................... 7.4.1 »GNU is not UNIX« ................................................... 7.4.2 Übersicht zur Geschichte der freien Software ............ Lesen Sie weiter ....................................................................

Es spielt der Mensch ............................................................. 351 Der Computer lernt spielen ................................................... 352

Inhalt

9.3

9.4

9.5

9.6 9.7

9.8

10

9.2.1 Ein Spiel, ein Computer – Nimrod ............................. 9.2.2 OXO ......................................................................... Mit Pingpong fing es an ......................................................... 9.3.1 Auf ins All! ................................................................ 9.3.2 Nicht nur reine Ballerei ............................................. Komm mit, ins Abenteuerland ... ........................................... 9.4.1 Adventures ............................................................... 9.4.2 Rouge und Boulder Dash .......................................... 9.4.3 Eine Schlange geht nach Hollywood .......................... 9.4.4 Rollenspiele .............................................................. Die größten Meilensteine in der Computerspiel-Geschichte ... 9.5.1 MobyGames ............................................................. 9.5.2 Von Partys, Money, Modding, MOG und MMOGs ... 9.5.3 Sonderformen ........................................................... Spielerwelt in Spielersprache ................................................. Noch mehr Spaß: ausgewählte Meilensteine der Computerspiele ..................................................................... 9.7.1 Defender of the Crown ............................................. 9.7.2 America’s Army ........................................................ 9.7.3 Spore ........................................................................ 9.7.4 Abenteuer Marke Eigenbau – mit dem Unreal Development Kit ...................................................... Lesen Sie weiter ....................................................................

352 357 359 362 366 376 376 380 384 384 389 389 391 393 400 405 405 407 409 413 418

Das Netz der Netze ...................................................................... 421 10.1

10.2

10.3

Ich hab’s gesagt ..................................................................... 10.1.1 Die Anfangsidee ....................................................... 10.1.2 Dezentrales Netz und vermittelte Datenübertragung ..................................................... IP-Adresse und Domainname ................................................ 10.2.1 Nichts als Zahlen ....................................................... 10.2.2 Noch mehr Zahlen: IPv6 ........................................... 10.2.3 Stets zu Diensten: das DNS ....................................... 10.2.4 Webadressen zu verkaufen – InterNIC/ICANN .......... 10.2.5 OpenNIC .................................................................. 10.2.6 Mit dem Modem in die Mailbox ............................... Das WWW entsteht .............................................................. 10.3.1 Fragen zu allem und jedem ....................................... 10.3.2 Die Server-Browser-Ehe ............................................

421 422 423 429 429 430 431 434 440 443 444 444 446

9

Inhalt

10.4

10.5 10.6

Browser ................................................................................. 10.4.1 Der Luchs machte den Anfang .................................. 10.4.2 Der Browserkrieg ...................................................... Das semantische Web ........................................................... Lesen Sie weiter ....................................................................

452 453 456 458 461

TEIL III Die Zukunft 11

Virtualisierung ............................................................................... 465 11.1

11.2 11.3

12

12.2 12.3 12.4

Cloud Computing .................................................................. 12.1.1 Was ist Cloud Computing? ........................................ 12.1.2 Die Anfänge des Cloud Computing ........................... 12.1.3 Ein mehrdeutiger Begriff ........................................... 12.1.4 iCloud ....................................................................... 12.1.5 eyeOS ....................................................................... 12.1.6 Sag mir, wo die Daten sind ....................................... 12.1.7 Cloud-Dienste .......................................................... Cloud – wichtiger Baustein der Informationszukunft .............. Noch mehr Spaß: Ubuntu One .............................................. Lesen Sie weiter ....................................................................

478 479 484 487 488 492 502 502 507 508 509

Denkmaschine ............................................................................... 513 13.1 13.2

13.3

10

465 466 467 468 469 472 476

Mein PC is’ ene Wolke ................................................................ 477 12.1

13

Ein Rechner zum Experimentieren ......................................... 11.1.1 Das Grundprinzip ...................................................... 11.1.2 Sinn und Zweck der Virtualisierung ........................... 11.1.3 Wie funktioniert das genau? ..................................... 11.1.4 Die wichtigsten Anbieter .......................................... Noch mehr Spaß: das JPC-Projekt .......................................... Lesen Sie weiter ....................................................................

Das Phantom an der Börse .................................................... Quantenmechanik ................................................................. 13.2.1 Quantenverschränkung ............................................. 13.2.2 Superposition ........................................................... 13.2.3 Qbits ........................................................................ Von der Natur lernen: neuronale Netzwerke und KI .............. 13.3.1 Das erste neuronale Netz ..........................................

513 517 517 518 518 520 521

Inhalt

13.4

13.5 13.6 13.7

13.3.2 Der Streit ums Perceptron ......................................... Zelluläre Automaten .............................................................. 13.4.1 Geschichte ................................................................ 13.4.2 Zellenspiele .............................................................. 13.4.3 Muster ...................................................................... 13.4.4 Zellraum ................................................................... 13.4.5 Metaautomaten ........................................................ 13.4.6 Wireworld ................................................................ 13.4.7 Anwendung und Praxis ............................................. 13.4.8 Also sprach Aristoteles .............................................. Noch mehr Spaß: die große Kunst der kleinen Zellen ............. Von der Turingmaschine zu rechnenden Räumen ................... Lesen Sie weiter ....................................................................

522 530 531 533 537 541 549 550 553 554 557 559 560

ANHANG A

VirtualBox (Windows / Mac OS X / Linux) ............................. 565 A.1

A.2

A.3 A.4

B

Installation und Anwendung von VirtualBox .......................... A.1.1 Die Installation von VirtualBox .................................. A.1.2 Der Einsatz von VirtualBox ........................................ Kommunikation mit dem Wirt ............................................... A.2.1 Wechseldatenträger .................................................. A.2.2 Gemeinsamer Ordner ................................................ VirtualBox deinstallieren ........................................................ Lesen Sie weiter ....................................................................

565 566 569 576 576 576 577 578

Die Installation von Java und JRE ............................................. 579 B.1 B.2 B.3

B.4 B.5 B.6

JDK oder JRE? ....................................................................... Hardwarevoraussetzungen ..................................................... Die Installation ...................................................................... B.3.1 Die Installation der Dokumentation .......................... B.3.2 Demos und Beispiele ................................................ B.3.3 Die Installation von Eclipse ....................................... Deinstallation ........................................................................ Noch mehr Spaß am Programmieren: 3D-Moleküle ............... Lesen Sie weiter ....................................................................

579 580 581 588 590 593 594 595 596

Index ............................................................................................................ 597

11

Praxis Computer ohne Programme 왘 왘

왘 왘 왘 왘

Die Antikythera-Maschine simulieren ....................................................... Planetarien simulieren – die wichtigsten Skriptbefehle der Stellarium-ScriptEngine ...................................................................... Simulation von Schickards Rechenmaschine ............................................. Simulation der Pascaline ........................................................................... Kurbelgetriebene Rechenmaschine ........................................................... Babbages Maschine ..................................................................................

55 63 67 71 77 83

Vom ersten Computer und anderen Rechnersauriern 왘 왘 왘 왘 왘

Rechnen mit dem Z3 ................................................................................ Rechnen mit dem ENIAC .......................................................................... Baby, Baby ... (Manchester Mark I simulieren) ......................................... Mainframe in the Box (Großrechner simulieren) ....................................... Betriebssysteme und Zusatzprogramme für IBM-Maschinen .....................

103 113 122 130 133

Von Äpfeln und Brotkästen 왘 왘 왘 왘 왘 왘 왘

Assembler mit dem PDP-1 ....................................................................... Die Apple I-Computerplatine ................................................................... Apple Lisa ................................................................................................ MSX-Rechner simulieren .......................................................................... Den C64 simulieren .................................................................................. C64-Spiele simulieren ............................................................................... Den C64 in BASIC programmieren ............................................................

150 157 158 164 170 173 175

Der Superrechner im Wohnzimmer 왘 왘 왘

C4004 simulieren ..................................................................................... 196 BOINC ..................................................................................................... 223 Rechnen mit der GPU ............................................................................... 225

Von Lady Ada bis F# 왘 왘 왘 왘

12

Im Inneren des Prozessors ........................................................................ Fortran ..................................................................................................... Die Programmierung einer Turingmaschine .............................................. Biberjagd ..................................................................................................

239 243 250 252

Praxis

왘 왘 왘 왘 왘 왘 왘 왘 왘

Ein einfaches GOTO-Programm ................................................................ Die Türme von Hanoi ............................................................................... bwBASIC .................................................................................................. ALGOL ..................................................................................................... Squeak (Smalltalk) .................................................................................... Pascal ....................................................................................................... C++ .......................................................................................................... Ada .......................................................................................................... BASIC/VB .................................................................................................

256 257 259 263 269 274 277 280 282

Softwaregeschichte(n) 왘 왘

Lotus Symphony ....................................................................................... 305 Oracle ...................................................................................................... 308

Von CP/M über DOS zu Windows 왘

Computer in Echtzeit ................................................................................ 341

Computerspiele 왘 왘 왘 왘 왘 왘 왘 왘 왘

Das erste Computerspiel ........................................................................... Pong in Java ............................................................................................. Spacewar .................................................................................................. Die Welt der Strategien ............................................................................ Zork ......................................................................................................... Boulder Dash ........................................................................................... Eigene Level entwerfen ............................................................................ Tangram ................................................................................................... Sokoban, der intelligente Kuli ..................................................................

352 360 363 373 378 382 383 395 397

Das Netz der Netze 왘 왘 왘 왘 왘 왘 왘 왘 왘

IP-Adresse ermitteln ................................................................................. Hosts-Datei unter Windows ..................................................................... Hosts-Datei unter Linux ............................................................................ Adresse auflösen ...................................................................................... Domainabfragen ....................................................................................... Zugang zum OpenNIC .............................................................................. Wie funktioniert das Internet? .................................................................. Feedly ...................................................................................................... Flock ........................................................................................................

430 431 433 435 438 440 447 459 460

13

Praxis

Virtualisierung 왘 왘

Virtuelles System auswählen ..................................................................... 471 Noch mehr Spaß: das JPC-Projekt ............................................................. 473

Mein PC is’ ene Wolke 왘 왘 왘 왘

gOS .......................................................................................................... iCloud ...................................................................................................... eyeOS ...................................................................................................... »Gänseblümchen« – Daisyworld ................................................................

480 489 497 505

Denkmaschine 왘 왘 왘 왘 왘

14

Quantenrechner simulieren ...................................................................... Neuronales Netz ...................................................................................... Das Märchennetz ..................................................................................... Conways Life – die Minimalversion ........................................................... Muster aus dem Game-of-Life-Automaten ................................................

519 523 527 534 538

»Das Internet ist doch bloß ein Hype.« – Bill Gates, 1995

Vorwort Im Jahr 2010 feiern wir den hundertsten Geburtstag des großen deutschen Computerpioniers. Deshalb wurde dieses Jahr zum Konrad-Zuse-Jahr erklärt. Konrad Ernst Otto Zuse wurde am 22. Juni 1910 in Berlin geboren. Damit wird, wie eine große Zeitung titelte, der Computer 100. Computer haben wie alle Dinge ihre ganz persönliche Geschichte – eine Geschichte, die gar nicht so langweilig und technisch-trocken ist, wie so mancher glaubt. Das ist durchaus ein Grund, sich intensiver damit zu befassen. Wie der Titel des Buches unschwer erraten lässt, wollen wir uns den originellen und »schnurrigen«, vor allem aber den interessanten Seiten der Computerhistorie zuwenden. Wie so oft in der Geschichte der Technik ist auch die Computertechnik gespickt mit Missverständnissen, ja mit »Unfällen« ganz eigener Art. Wir wollen versuchen, die Spuren, die der Computer in der Zeit hinterlassen hat, praktisch zu lesen. Das soll heißen: Wir werden uns Programme aus den betrachteten »Epochen« ansehen und versuchen, selbst zu programmieren, wo immer es sinnvoll scheint. Also geht es neben der Hardware auch um Software, ja sogar um Computerspiele, denn diese sind mit eine der stärksten Triebkräfte in der Geschichte der EDV. Die angesprochenen Themen kann dieses Buch natürlich nicht umfassend abhandeln, dazu ist die Geschichte der Hard- und Software einfach zu umfangreich. Es kann aber einen Überblick über die wichtigsten »Schlachtfelder« und »Heerführer« im Kampf um die Datenverarbeitung mit Hilfe von Maschinen liefern. Trotzdem soll dies natürlich kein Lehrbuch sein, vor allen Dingen auch kein Buch zu einer bestimmten Programmiersprache. Dafür gibt es andere Bücher, die in der Reihe »Coding for Fun« erschienen sind. Beherrscht man jedoch die Programmierung, z. B. eine Sprache wie Java, kann man die Beispiele nicht nur vom Computer ausführen lassen; bei dem einen oder anderen Programm, dessen Quellcode beiliegt, kann man sich sogar anschauen, wie die Software damals geschrieben wurde und was sich die Entwickler dabei gedacht haben. Man kann sich Anregungen bei den ganz großen Softwareentwicklern holen, etwa bei

15

Vorwort

Niklaus Wirth, dem Erfinder der Programmiersprachen Pascal, Modula und Oberon, oder bei James Gosling, dem Entwickler von Java. Programmieren zu können soll jedoch so wenig Bedingung für das Verstehen dieses Buches sein wie Lateinkenntnisse für ein Buch über die Geschichte der Römer nötig sind. Sie können also ganz vorbehaltlos an die Sache herangehen. Dieses Buch möchte vor allem eines vermitteln: die Freude an neuen Ideen, also den Spaß, den all die Pioniere empfanden, als sie etwas zum ersten Mal ausprobierten. So wie Konrad Zuse, als er sah, dass man durch die Nutzung binärer Zahlen mit einer elektrischen Maschine und unter Zuhilfenahme von Blechstreifen rechnen lassen konnte. Aber wir wollen uns nicht nur antiquierte Maschinen ansehen, die in irgendwelchen Museen vor sich hin rosten. Ich möchte darüber hinaus einen Blick in die Zukunft werfen, auch wenn ich mich dabei vielleicht irren mag. Welches Geschichtsbuch bietet schon auf seinen letzten Seiten einen Ausblick in die Welt von morgen und übermorgen? Bei einem Buch zum Thema Computergeschichte jedoch darf ein Ausblick, wie ich meine, nicht fehlen. So, nun wünsche ich jedem Leser ein Maximum an Spaß mit Computergeschichte(n)!

Hinweise zur Benutzung des Buches Das Buch ist so weit wie möglich chronologisch aufgebaut, was aber nicht bedeutet, dass die vorausgehenden Kapitel für das Verständnis der folgenden Texte erforderlich sind. Der geneigte Leser kann daher jeweils das lesen, was ihn gerade interessiert, ohne den Überblick zu verlieren. Um die praktischen Beispiele nachvollziehen zu können, ist es ratsam, sich eine virtuelle Maschine einzurichten. Dazu im folgenden Abschnitt mehr. Wo es mir sinnvoll schien, habe ich interessante Aussagen der Computerpioniere eingestreut. Oft handelt es sich dabei um Irrtümer, die zeigen sollen, wie rasch und umfassend sich die Sichtweise auf den Computer geändert hat, und nicht, wie sehr sich die Fachleute irrten oder wie dumm sie gewesen wären. Damit sich die einzelnen Bestandteile des Buches wie Programmcode und Kapiteleinführungen besser voneinander abheben, wurden jeweils unterschiedliche Schriften verwendet. Sie sind hier vor der Aufzählung der verwendeten Abkürzungen dargestellt, damit Sie einen Überblick gewinnen können.

16

Vorwort

Darstellung

Verwendung

Kapiteleinführung

Vorwort vor den einzelnen Kapiteln

Listing

Programmcode

CD:/beispiele/kapitel01/pro001 Hinweis zu den Code-Beispielen auf der DVD-ROM Start 폷 Programm 폷 VBasic

Menüfolge

Erläuterung, die sinngemäß zu ersetzen ist

(Ctrl)+(H)

Tastatureingabe

Fachbegriff

Name oder Fachbegriff

Fett

Hervorhebung wichtiger Wörter und Begriffe

Tabelle 1

Tabelle der Zeichenformate

Abkürzung

Bedeutung

Start-Icon

Start-Kreis von Windows (bei Windows 7/Windows Vista) und Start-Icon (bei älteren Windows-Versionen)

GUI

grafische Nutzerschnittstelle (aus Entwicklersicht)

IDE

integrierte Entwicklungsumgebung

LMT

linke Maustaste anklicken

OOP

objektorientierte Programmierung

RMT

rechte Maustaste anklicken

UML

Diagramme, um den Aufbau von OO-Programmen zu beschreiben

URL

Webadresse

VM

virtuelle Maschine, insbesondere Java-Maschine

Tabelle 2

Tabelle der verwendeten Abkürzungen

Noch mehr Spaß mit der grauen Kiste Nun zu einem der wichtigsten Kapitel des Buches. Es befindet sich ziemlich am Schluss und heißt »VirtualBox (Windows / Mac OS X / Linux)« – Anhang A. Dieses Kapitel sollte in jedem Fall zuerst durchgearbeitet werden, es sei denn, Sie sind ein Fachmann für Virtualisierung und haben auf Ihrem Rechner bereits Systeme wie VirtualBox in Gebrauch. Mit Hilfe dieses Kapitels können Sie Ihren Rechner so vorbereiten, dass Sie andere Betriebssysteme installieren können, ohne das bestehende System verän-

17

Vorwort

dern zu müssen. Auch wenn Sie noch nie einen Rechner selbst konfiguriert haben, sollten Sie es mit Hilfe dieses Kapitels versuchen. Es lohnt sich ... Zunächst geht es nur darum, ein Virtualisierungsprogramm zu installieren. Diese Software »gaukelt« dann einen eigenständigen Rechner im Betriebssystem Ihres Rechners vor, mit dem man beliebig herumexperimentieren kann, ohne dass etwas kaputtgeht. Sollte einmal etwas schieflaufen, löscht man einfach den »kaputten« Rechner aus dem Programm und erzeugt einen neuen. Sollte es ganz schlimm kommen, deinstalliert man die Virtualisierungssoftware und installiert sie wieder neu. Außerdem bewahrt ein virtuelles System Ihr reales System vor Viren, wenn Sie etwas Neues immer zuerst auf einem virtuellen Rechner installieren, um es zu testen. Auch bei der beiliegenden Software von der Buch-DVD und bei Software, die Sie von im Buch genannten Adressen aus dem Internet laden, kann es vorkommen, dass Ihre Virensoftware Virenbefall meldet. Bei der von mir getesteten Software handelte es sich durchweg um Fehlalarm. Trotzdem können sich jederzeit böswillige Viren einschleichen. Achtung, wichtig! Verwenden Sie stets virtuelle Systeme. Selbst wenn Sie dort das gleiche Betriebssystem betreiben wie auf dem Hauptrechner. Dadurch können Sie Virenbefall auf Ihrem eigentlichen Computer verhindern.

Also, alles völlig ungefährlich, wenn man es richtig macht. Oder anders gesagt: Wenn man nicht kompletten Unsinn macht, kann man mit der Software und den Beispielen im Buch keinen Schaden am Computer anrichten. Was Sie noch unbedingt benötigen, um die Beispielprogramme des Buches nachvollziehen zu können, ist ein Java-Laufzeitsystem. Wie man dieses installiert, lesen Sie ebenfalls im Anhang (»Die Installation von Java und JRE« – Anhang B). Sinnvollerweise installieren Sie sich so etwas gleich auf dem virtuellen Rechner.

Zur DVD-ROM Auf der beiliegenden DVD ist die gesamte Software enthalten, die für das Nachvollziehen der Beschreibungen und der Sachverhalte aus dem Buch erforderlich ist. Es steht Ihnen natürlich frei, neuere Versionen oder andere Software aus dem Internet downzuloaden. Allerdings sollten Sie dann auch berücksichtigen, dass weder der Verlag noch der Autor Fragen zu der Software beantworten können.

18

Vorwort

Arbeiten Sie also, wenn möglich, mit der Software auf der DVD. Dann ergeben sich auch die wenigsten Diskrepanzen zum Inhalt des Buches, und Sie erzielen den größtmöglichen Lern- und Spaßeffekt. Auf der DVD befinden sich zudem zahlreiche Dokumentationen zur Software und zu weiterführenden Sachgebieten, so dass Sie sich über das Buch hinaus weiter in die Thematik einarbeiten können. Helfen und weiterführen sollten auch die überall im Buch eingestreuten Webadressen.

Danksagung In diesem Buch, das ich als Reminiszenz an den großen Erfinder verstehe, gebührt der größte Dank Herrn Konrad Zuse. Er ist derjenige, der vor vielen Jahren den Computer als einfaches Rechenwerkzeug erdacht hat. Was nach fast 70 Jahren aus dieser genialen Idee geworden ist, das will dieses Buch zeigen. Dank geht außerdem: ... an meine Frau Helga Rosita, ganz besonders für ihr Verständnis. ... an Herrn Uwe Baumann, der bei Microsoft eine Webseite zum spielerischen Erlernen von Programmiersprachen betreut. ... an alle, die Abbildungen zur Geschichte des Computers beigesteuert haben, insbesondere an Herrn Heribert Müller vom Technikum29 für seine ansprechenden Bilder. ... an Herrn Henry Raymond, der mir eine sehr schöne Z3-Simulation zur Verfügung gestellt hat. ... an Herrn Till Zoppke, der mir seine ENIAC-Simulation für die beiliegende DVD überließ. Ebenfalls zu danken habe ich Herrn Christof Elmiger für die Überlassung seiner Arbeit zu L-Systemen. Ein herzliches Dankeschön an Herrn Thomas Jetter für das Programm MemBrain. ... an Herrn Axel Koerfer von der Bitmanagement Software GmbH für die Erlaubnis, den VRML/X3D Viewer BS Contact beilegen zu dürfen. ... an Frau Biggi Lehrl für die Abbildung ihres Rosenkranzes. ... an meine Lektorin Judith Stevens-Lemoine, die sich viel Mühe mit der Betreuung dieses Buches gegeben hat. Hätte sie sich meinen neuen Ideen gegenüber nicht aufgeschlossen gezeigt, wäre dieses Buch nie zustande gekommen. Den gleichen Dank schulde ich Frau Anne Scheibe von Galileo Press.

19

Vorwort

... an Herrn Prof. Peter Ziese, der sich für mein Coding for Fun-Buch begeistern konnte und nicht mit Anregungen gespart hat. ... an Herrn Eckart Prause für die Überlassung des BIOS-Kompendiums, das vielen Nutzern bei BIOS-Problemen weiterhalf und weiterhin hilft und somit hier Teil der PC-Geschichte wurde. ... für die Abbildung von SAP an Herrn Rungwerth, und das Bild von der Software AG verdanke ich Herrn Kockrick. ... an meinen Lehrer und Mentor, Herrn Prof. Dr. Peter Zöller-Greer, der mich durch seine Forschungen im Bereich der KI vielfach angeregt und unterstützt hat. Mit seinen Worten möchte ich sagen: »Der Mensch, wie er in der Natur vorkommt, benötigt im Grunde keinen Computer, der Computer aber in jedem Fall den Menschen.« Ein ganz besonderer Dank gebührt jener endlosen Schar an Hobbyprogrammierern, die mit unvergleichlichem Elan und Enthusiasmus ihre Freizeit dafür opfern, geniale Softwareprogramme zu erstellen, die sie kostenlos weitergeben. Ohne ihre Arbeit wäre an ein solches Buch gar nicht zu denken gewesen. Denn ohne sie es gäbe kein FreeDOS, kein Squeak-Smalltalk und vor allem kein Linux oder Ubuntu. Und ehe ich es vergesse ... Das herzlichste Dankeschön geht natürlich an Sie, meine Leser, die einfach Spaß an einem Buch wie diesem haben und denen das Geld dafür nicht zu schade ist. Ich wünsche mir, dass Sie das Buch mit der gleichen Freude und Begeisterung lesen, mit der ich es geschrieben habe.

H. R. Wieland

20

TEIL I Geschichte der Hardware

»Unsere Hardware ist schon ziemlich hart. Zumindest viel härter als die Köpfe unserer meisten Nutzer.« – Bandarbeiter eines Computerherstellers

»Der Computer ist eine Rechenmaschine, die auf dem Weg ist, denken zu lernen.« – Anonymus, 2009 Dieser etwas zu joviale Satz ist in einem Punkt richtig: Der Computer ist eine Rechenmaschine. Auch wenn er heute beliebige Daten verarbeiten kann, ist und bleibt er eine Rechenmaschine. Deshalb beginnt seine Geschichte eigentlich bereits mit der Entdeckung der Zahl.

1

Von Rosenkranz und Rechenschieber

30.000 v. Chr.

3.000 v. Chr.

1100 v. Chr.

1624 1654

1910 2000

Entdeckung der Zahl Keilschrift Sexagesimalsystem Abakus Gunters Scale Rechenschieber

1.1

Eins, zwei, drei ...

»Adam und Eva waren die Ersten ...«, sagte mein Vater stets, und so fing er auch mit seinen Geschichten an. Das muss vererbt sein, denn auch ich beginne mit meiner Geschichte der Hard- und Software ganz von vorn. Leider kann uns niemand sagen, wie das wohl war mit der ersten Zahl, dem Zählen und später mit den ersten Berechnungen.

23

1


Noch heute gibt es Naturvölker, die nur die Zahl Eins kennen, und solche, die nur bis drei zählen können, wie eine Redensart bei uns sagt. Ihr Zahlensystem kennt sozusagen lediglich die Zahlen Eins, Zwei, Drei und Viele. Mit der Entdeckung der Zahl wurde zugleich die Rechenhilfe erfunden. Auch wenn es vielleicht 30.000 Jahre her ist – man kennt diese Rechenhilfe heute noch sehr genau und braucht nicht einmal tief zu graben, um solche Artefakte zu finden. Wir haben sie nämlich stets bei der Hand: Es sind unsere zehn Finger. Trotzdem wissen wir nicht, ob das erste Zahlensystem der Menschheit ein Zehnersystem war. Es gibt nämlich nicht nur ein Zahlensystem, wie man vielleicht denken mag, wenn man sein Leben lang nur mit dem Zehnersystem gerechnet hat.

Abbildung 1.1

Der Daumen steht für die Eins.

Der gehobene Daumen hat vielerlei Bedeutungen, vor allem aber steht er für die Zahl Eins. Er steht für Erfolg, aber auch für einen selbst. Denkt man sich in die Steinzeit zurück, kann man sich vielleicht vorstellen, wie ein Häuptling einen Jagdtrupp zusammenstellte: für jeden Finger einen Begleiter, wobei der erste, der Daumen, er selbst war. In früherer Zeit gab es 5er, 12er, 20er, 60er und wahrscheinlich noch einige Zahlensysteme mehr. Die ersten wirklich großen Mathematiker waren die Babylonier und die Ägypter. Sie waren damit vermutlich auch die Ersten, die Rechenhilfen in größerem Umfang für komplexe Berechnungen einsetzten. Ist man in der Lage, Zahlen aufzuzeichnen, sie mit Zahlzeichen festzuhalten, so bringt dies

24


schon eine große Rechenerleichterung. Den Fingern folgten also die Zahlzeichen, bevor die ersten mechanischen Rechenhilfen entwickelt wurden. Das Zwölfersystem ist neben dem Dual- und dem Zehnersystem das bei uns am häufigsten genutzte System. Es kommt beispielsweise bei der Zeitrechnung ausschließlich vor. Ein Tag hat 24 Stunden, ein halber Tag 12, eine Stunde 60 Minuten und die Minute ebenso viele Sekunden. Eigentlich ist das kein echtes Zwölfersystem, sondern eine Mischung aus Zwölfer- und 60er-System. Bereits die Babylonier nutzten dieses gemischte System. Ureigentlich war es ein Sexagesimalsystem, also ein Sechzigersystem. Ihre Grundzahl war nämlich die 60. Sie erwies sich als sehr praktisch, schon allein deshalb, weil sie durch 10 Faktoren teilbar ist. Diese Faktoren sind: 2, 3, 4, 5, 6, 10, 12, 15, 20, 30 Diesen praktischen Umstand nutzen wir heute noch. Glauben Sie nicht? Denken Sie nur an das Ziffernblatt. Die Viertelstunde, die halbe Stunde, die Aufteilung in fünf Minuten, zehn Minuten, 3 * 20 Minuten. Die französische Revolution versuchte das Zwölfersystem in der Zeitrechnung auszumerzen. Mit der Monarchie kehrte jedoch das alte System zurück. Nun hatten die Babylonier allerdings auch nur zehn Finger, so wie wir. Daher bleibt die Frage: »Wie haben sie gerechnet, wenn sie auf ihren manuellen ›Taschenrechner‹ angewiesen waren?« In der Tat kann man die Finger auch ausgezeichnet für das Zwölfer- und 60er-System verwenden. Wenn man die Gelenkfalten der Handinnenfläche zählt, kommt man genau auf zwölf, sofern man den Daumen weglässt. Der Daumen wird deshalb nicht mitgezählt, weil er selbst als Zeiger verwendet wird. Man zählt also mit dem rechten Daumen die Gelenkfalten der rechten Hand und mit den fünf Fingern der linken Hand die Anzahl der Zwölfer. So kommt man auf 5 * 12 gleich 60. Eben die 60, die wichtigste Zahl im Zahlensystem der Babylonier. Das folgende Bild zeigt die Zahl 18 (siehe Abbildung 1.2). Mit der rechten Hand auf die oberste Gliedfalte des Mittelfingers gezeigt, ergibt die 6, und der erste Finger der linken Hand zeigt an, dass schon einmal bis zwölf gezählt wurde, also 6 + 12 = 18. Die Keilschrifttafeln haben folgende Stellenschreibweise: 1. Spalte: Einer 2. Spalte: Zehner 3. Spalte: Sechziger 4. Spalte: Dreitausendsechshunderter (60 * 60)

25

1.1

1


Abbildung 1.2

Zählen wie in Babylon (die Zahl 18)

Die möglichen Zahlzeichen waren: 왘

für einen Wert in der Einer-, der 60er- oder 60²er-Spalte stand für die Null im Innern einer Ziffer

왘 왘

stand für eine 10

Die Zahlen wurden von rechts nach links dargestellt, genau so, wie wir es heute noch handhaben. Eine babylonische Zahl konnte etwa so aussehen: |

|

|

|

|

Verstehen lässt sich das als: 6*1 0 * 10 2 * 60 1 * 3.600 = 3.726 Außer in der Zeitrechnung hat sich das Sexagesimalsystem auch in der Winkelmessung bis auf den heutigen Tag erhalten.

26


Zahlensysteme Bei Zahlensystemen unterscheidet man zwischen Stellenwertsystemen, zu denen unser Zehnersystem gehört, Additionssystemen und Mischformen. Beim Additionssystem wird die dargestellte Zahl durch Zusammenzählen der dargestellten Zahlzeichen ermittelt. Ein einfaches Additionssystem ist beispielsweise die Strichliste. Durch Anfügen von Strichen und Durchstreichen kann man sie sogar als Rechenhilfe nutzen. Bei Stellenwertsystemen hängt der Wert einer Zahl davon ab, wo das Zahlzeichen steht. Fast alle heute gebrauchten Zahlensysteme sind Stellenwertsysteme. Darüber hinaus gibt es noch Mischformen. Die römischen Ziffern sind ein derartiges System. Alle Zahlen werden addiert, aber es kommt darauf an, ob die I vor der V oder dahinter steht, um eine 4 oder eine 6 zu ergeben. Römische Ziffern I 1

V

5

X

10

L

50

C

100

D

500

M

1.000

MMX ergibt somit 2.010.

Noch wichtiger als dieses Zahlensystem ist heutzutage das binäre Zahlensystem, auch wenn es den meisten Menschen nicht so geläufig ist, weil es gänzlich versteckt im Innern der Computer vor sich hin werkelt. Dort gibt es, wenn man so will, eine völlig fremde Welt, die nur aus endlosen Reihen von Nullen und Einsen besteht. Könnte man sehen, wie diese beiden Zahlen unglaublich schnell durch die winzigen Leiterbahnen der Prozessoren rasen – so, wie die Pioniere an den ersten Rechnern mit blinkenden Lämpchen sehen konnten, welche Binärzahlen gerade verarbeitet wurden –, wäre uns die Wundermaschine Computer noch unbegreiflicher. Alles, was wir mit dem Computer machen, besteht nur aus Nullen und Einsen – ob das die Zeilen dieses Buches in meinem Textverarbeitungsprogramm sind, die Straßenkarte von Frankfurt in unserem Navigationssystem, die 3D-Darstellung des Traumhauses im CAD-System unseres Architekten, das Digitalfoto der Jüngsten, ihre ersten Schritte, gebannt im digitalen Film auf YouTube oder die atemberaubenden Szenen im 3D-Kinokassenschlager Avatar. Man sollte sich das einmal vergegenwärtigen: Die ganze Welt wird inzwischen von endlosen Reihen von Nullen und Einsen geregelt, dargestellt und beherrscht. Erst die Bedeutung, die wir bestimmten Bruchstücken dieser endlosen Zahlenreihe

27

1.1

1


im Innern eines Rechners beimessen, die Typen von Daten, ihre Umsetzung in Zeichen, grafische Elemente, Töne und anderes mehr macht aus 0 und 1 das, was wir von der Arbeit des Computers nutzen. Ohne uns, unsere Phantasie und unsere Sinne bliebe das alles nur das, was es im Grunde auch lediglich ist: kurze Stromstöße in winzigen Leitungen. Das Geniale daran war, wirklich zu erkennen, welches Potential in zwei Ziffern steckt. Diesen Weitblick hatte vor über 70 Jahren ein einzelner Mann: Konrad Zuse, der Erfinder des Computers.

1.2

Hexadezimal mit dem Windows Calculator

Natürlich hat man seine Schwierigkeiten damit, eine Zahl von einem in ein anderes Zahlensystem umzurechnen, zumal in der Informatik nicht nur das binäre Zahlensystem, sondern auch das sogenannte Hexadezimalsystem genutzt wird – nicht zu verwechseln mit dem Sexagesimalsystem der Babylonier. Während dort die Basis 60 ist, ist sie beim Hexadezimalsystem die Zahl 16. Da wir aber üblicherweise nur zehn Zahlzeichen haben – von der 0 bis zur 9 –, fehlen uns noch sechs Zahlzeichen, um hexadezimale Zahlen schreiben zu können. Etwa seit 1957 nutzt man dazu die Buchstaben A bis F. Warum aber nutzt man dieses merkwürdige Zahlensystem? Das hängt erstaunlicherweise mit den Buchstaben unseres Alphabets zusammen. Groß- und Kleinbuchstaben ergeben insgesamt 58 Zeichen; zählt man die zehn Zahlzeichen dazu und + und – sowie die Anführungs- und anderen Satzzeichen, kommt man auf weit über 64. Da der Computer mit Binärzahlen arbeitet, entsprechen die Stellen seiner Zahlen den Zweierpotenzen. 64 ist eine solche Zweierpotenz, die nächste wäre 128. Das sind sieben Binärstellen. Der erste Mikroprozessor von Intel, der 4004, hatte beispielsweise einen nur 4 Bit breiten Datenbus. Er konnte darüber also nur 4 Bit breite Zahlen senden. Die damit größtmögliche Binärzahl war also 1111, das entspricht der dezimalen 15. Um die weiteren Ausführungen besser verfolgen zu können, sollten Sie den Taschenrechner Ihres Betriebssystems nutzen, wie wir es Ihnen beispielhaft am Taschenrechner von Windows zeigen werden. Die übrigen Betriebssysteme verfügen über ähnliche Taschenrechner. Gestartet wird er über: Start 폷 Alle Programme 폷 Zubehör 폷 Rechner. Um mit Binärzahlen rechnen zu können, schaltet man auf wissenschaftliche Darstellung um: Ansicht 폷 Wissenschaftlich.

28

Hexadezimal mit dem Windows Calculator

Abbildung 1.3

Der Windows-Rechner

Unter dem Anzeigefeld stellt der Rechner einige Optionsschaltflächen zur Verfügung, mit denen man auf vier verschiedene Zahlensysteme umschalten kann: 왘

Hex: Hexadezimalsystem

왘

Dez: Dezimalsystem

왘

Okt: Oktalsystem

왘

Bin: Binärsystem

Stellt man auf Dez und gibt die Zahl 15 ein, so erhält man nach dem Umschalten auf Bin die Zahl 1111. Achtung: Der Rechner schaltet jetzt die Zahlenfelder von 2 bis 9 aus, damit man nur Nullen und Einsen eingeben kann. Hatte der erste Intel-Mikroprozessor auf jeder Datenleitung Strom, so bedeutete das 1111. 16 sieht binär so aus: 10000. Um diese Zahl darzustellen, hätte der 4004 eine fünfte Datenleitung gebraucht, die er ja nicht hatte. Sie erkennen gleich zwei Sachverhalte: In einem Computer ist die Leistung stark von der Anzahl der Datenleitungen abhängig – man spricht von Busbreite –, und die größte Zahl auf einer bestimmten Busbreite (Stellenanzahl) ist immer um 1 kleiner als die Zweierpotenz, die der Anzahl der Stellen entspricht. Das ist in jedem Stellensystem so. 99 ist die größte Zahl, die wir im Zehnersystem mit zwei Stellen schreiben können, und 10 hoch 2 ist 100, die nächste Zahl also 99 + 1. Man kam also mit 4 und sogar mit 6 Bit Breite nicht aus, um alle Buchstaben und Zeichen einer Schreibmaschinentastatur im Computer kodieren zu können. Außerdem lag es nahe, im 4004 zwei Zahlen aneinanderzuhängen, um mehr kodieren zu können. Somit hatte man eine 8 Bit lange Zahl. Acht binäre Stellen lassen maximal die Zahl 11111111 zu, die der dezimalen 255 entspricht. Schalten

29

1.2

1


Sie nun einmal auf Hexadezimal um. Es wird eine FF angezeigt. F steht bekanntlich für 15.

Abbildung 1.4

255 hexadezimal dargestellt

Eine Stelle im hexadezimalen System entspricht sozusagen den vier Leitungen des Intel 4004. Somit ist es relativ komfortabel, binäre Zahlen hexadezimal darzustellen, man schreibt statt binär 100000000 einfach 100, dezimal muss man immerhin 256 schreiben. Aber warum ist das so? Ganz einfach: Die 16, die Basis des Hexadezimalsystems, ist eine Potenz der Zahl 2, der Basis des Binärsystems. Der Rechner von Windows kann darüber hinaus auch mit dem Oktalsystem rechnen. Dieses hat die Basis 8, auch eine Zweierpotenz. Es wurde zeitweise ebenfalls in der EDV verwendet, entspricht aber nur drei Binärstellen und war mit der Fortentwicklung der Computer deshalb bald unbrauchbar. Bearbeitet der Computer logische Probleme, steht die binäre 1 für ja, die 0 für nein. »Das Unsympathische an Computern ist, dass sie nur Ja oder Nein sagen können, aber nicht vielleicht.« – Brigitte Bardot

1.3

Der heilige Computer aus gläsernen Perlen

Erst genügte eine Linie im Sand, auf die man Steine setzte, später fädelte man Perlen auf Schnüre. Immer ging es darum, sich das Zählen zu erleichtern. Eine dieser »Rechenmaschinen« der ganz besonderen Art – sozusagen eine heilige Rechenmaschine – ist noch heute in Gebrauch: Es ist der Rosenkranz. Er dient einfach nur dazu, Gebete zu zählen. Doch ganz so einfach ist es auch wieder nicht. Denn ein Rosenkranz ist noch viel mehr als nur ein Abzählhilfsmittel; er

30

Der heilige Computer aus gläsernen Perlen

besteht nämlich nicht nur aus gleichen Perlen im gleichen Abstand, er enthält darüber hinaus ein richtiges »Programm«. Dieses ist sozusagen durch die Aufeinanderfolge der 59 Perlen und ihrer Abstände in der »Hardware« fest verankert. Die Zahl 59 ist auch nicht ganz zufällig. Zählt man nämlich das Kreuz zu den Perlen dazu, kommt man auf 60 und hat wieder diese magische Zahl der Babylonier, die sich so oft teilen lässt. Das »Programm« des Rosenkranzes: Das Kreuzzeichen Das Glaubensbekenntnis Ehre sei dem Vater Vaterunser 3 Mal: Ave Maria Ehre sei dem Vater 5 Mal: Vaterunser 10 Mal: Ave Maria Ehre sei dem Vater

Diese Anweisungen haben alles, was ein modernes Computerprogramm auszeichnet. Es gibt drei zählende Schleifen, eine verschachtelte Schleife und, wenn man so will, sogar eine Endlosschleife.

© Biggi Lehrl; www.dieglasvitrine.de

Alle Wiederholungen (Schleifen), bis auf die Endlosschleife des Kranzes selbst, sind jedoch seriell ausgeführt, also keine echten Schleifen. Für jedes Gebet gibt es eine Perle.

Abbildung 1.5

Rosenkranz (ein Werk der Glaskünstlerin Biggi Lehrl)

31

1.3

1


Ein solch altes Programm fordert regelrecht dazu auf, mit dem Computer nachprogrammiert zu werden. Auf der folgenden Webseite kann man sich die »Onlineversion« ansehen: http://www.liborius.de/unser-glaube/der-rosenkranz Gebetsketten Der Rosenkranz zählt zu den Gebetsketten, die es in zahlreichen Religionen gibt. Der Rosenkranz des Christentums hat 59 Perlen, seine Erfindung wird der angelsächsischen Adligen Lady Godiva (um 1000) zugeschrieben. Die Gebetsschnur der Hindus und Buddhisten, die Mala, hat 108 Perlen, wobei die Perlen im Hinduismus für die Namen der Gottheiten stehen, im Buddhismus für die gesammelten Bände von Buddhas Lehre. Der Tasbih des Islam ist eine Gebetsschnur mit meist 33 oder 99 Perlen und dient zum Zählen der Lobpreisungen Allahs. Allen Gebetsschnüren gemeinsam ist, dass sie als Zählhilfen dienen. Während man mit den Fingern mechanisch zählt, kann man sich ganz aufs Gebet konzentrieren, ohne sich zu verzählen.

Aus den Schnüren wurden Stangen, und man nannte diese Rechenhilfe nun Abakus. Während man mit Schnüren nur abzählen konnte, hatte man mit dem Abakus durch seine an beliebige Stellen schiebbaren Kugeln bereits eine richtige »Rechenmaschine« (siehe Abbildung 1.10). Trotzdem ist er, wie die anderen »Geräte« vor ihm, nur ein Hilfsmittel zum »Notieren« von Zahlen. Selbständig Rechenschritte durchführen kann er nicht. Diese Rechenhilfen wurden schließlich durch Rechenmaschinen verdrängt. Eine Neuentwicklung – die noch zu diesen einfachen Hilfsmitteln zu zählen ist, auch wenn man mit ihrer Hilfe bereits kompliziertere Berechnungen ausführen konnte – gab es jedoch im 16. Jahrhundert. Gemeint ist der Rechenschieber.

1.4

Von Seeschlachten und Zahlenschiebern

Der Kanonendonner rollte über die schwankenden Schiffsleiber hin. Maste krachten, Planken ächzten, stöhnten, knackten und zersplitterten schließlich mit lautem Knall, wenn die schweren Kugeln der Geschütze sie durchschlugen. In der Kapitänskajüte lagen die Seekarten wild zerstreut. Die Lampe schwankte langsam im Takt des Seegangs. Nelson beugte sich noch einmal über den Tisch, setzte den Stechzirkel an. Nur diesmal nicht auf einer der unzähligen nautischen Karten, sondern auf einer dünnen Holzlatte. Er nannte das Lineal »Gunter's Scale«. Es war den Linealen nicht unähnlich, mit denen man den Kurs auf die Seekarte zeichnen konnte. Trotzdem hatte es etwas Unheimliches. Auch dem ersten Offizier, der noch seine Probleme 32


mit der Rechenlatte hatte, schien es nicht ganz geheuer. Er nutzte lieber einen der modernen, aber langsameren Rechenschieber. »Ihr könnt den Zirkel nicht richtig benutzen, Lindsay!«, schimpfte der Admiral stets. »Deshalb sind eure Rechnereien mit der Gunter's Scale reiner Mist. Wenn Ihr den Stechzirkel anhebt, drückt Ihr ihn zusammen, ohne es zu merken. Lasst Euch die Schraube vom Schiffszimmermann fester anziehen, bevor Ihr ihn noch mal in die Gunter's Scale stecht.« Nelson drohte mit dem Lineal, der Gunter's Scale, die er nutzte, um die Geschwindigkeiten in Strecken umzurechnen, die die Linienschiffe bis zum nächsten Morgen schaffen konnten. Es würde zur Schlacht kommen, zu einer der denkwürdigsten Schlachten in der Seefahrtsgeschichte. Später würde man sagen, nach der Seeschlacht bei Actium sei die Schlacht bei Trafalgar eine der wenigen entscheidenden Seeschlachten der Weltgeschichte gewesen. Lord Nelson fiel in dieser Schlacht, obwohl sein Gegner Vizeadmiral Pierre Charles de Villeneuve und damit Napoleon entscheidend geschlagen wurde. Die Gunter's Scale dagegen wurde noch bis etwa 1910 genutzt, obwohl sie schon zu Nelsons Zeiten längst durch den praktischeren Rechenschieber verdrängt wurde. Die Gunter's Scale Die Gunter's Scale war eine Leiste aus Buchsbaum, weil sich dieses Holz bei wechselnder Luftfeuchte relativ wenig verformte. Auf der Vorder- und oft auch auf der Rückseite waren zahlreiche Skalen eingebrannt oder eingeritzt. Neben Längenskalen gab es Skalen mit logarithmischer Einteilung, was bedeutet, dass die Abstände mit zunehmender Größe der Zahlen immer kleiner wurden. Nahm man mit dem Zirkel den Abstand von der Null bis zur Vier und steckte ihn bei der Fünf ab, landete man bei der 20, man hatte also 4 * 5 ermittelt. Die Gunter's Scale wurde in der Navigation von Schiffen bis ins 20. Jahrhundert genutzt, weil dabei ohnehin immer Zirkel und Längenmaßstab verwendet wurden.

1.4.1

Rechenstäbe und Rechenschieber

Die Idee, die dem Rechenschieber zugrunde liegt, baut auf einer Eigenart der Logarithmen auf. Multiplikation und Division werden bei Exponentialzahlen durch ihr Pendant bei der Strichrechnung ersetzt. Aus Multiplikation wird Addition und aus Division Subtraktion. Das war schon bei der Gunter's Scale so, wobei man die Längen mit dem Zirkel abgriff. Logarithmen haben beim Rechnen Vorteile, selbst wenn man von Hand auf Papier rechnet. Das Problem ist die Umrechnung von der natürlichen Zahl auf den Logarithmus und wieder zurück.

33

1.4

1


1594 veröffentlichte der Schotte John Napier erstmals die von ihm entwickelten Logarithmen. Außerdem entwickelte er eine Rechenhilfe, die sogenannten Napierstäbe, und beschrieb sie in seinem 1617 erschienenen Werk »Rabdologiae seu numeratio per virgulas libri duo«. Die Napierschen Rechenstäbe Ausgehend von seiner Entdeckung der Logarithmen entwickelte der schottische Mathematiker John Napier die Napierschen Rechenstäbe. Auf den Stäben ist das einfache Einmaleins aufgetragen. Also auf dem Stab mit der 5 die Reihe 10, 15, 20, 25 usw. Die Stäbe sind quadratisch, können also auf jeder Seite eine Reihe besitzen. Die Zahlen stehen nicht nebeneinander, sondern diagonal versetzt. Dadurch kommen die Zehner des rechten Stabes schräg über den Einern des links liegenden Stabes zu stehen. Um das Ergebnis zu erhalten, wird also diagonal addiert.

Man muss das praktisch vor sich sehen, um es verstehen zu können. Auch hierzu gibt es im Internet einige Beispiele. Ein Programm, das die Stäbe erklärt und ein Beispiel durchrechnet ist, befindet sich auf der DVD zum Buch (Software zum Buch\Kap01\Napier\naprods.zip). Nach dem Auspacken kann das Programm als naprods.exe gestartet werden.

Abbildung 1.6

34

Rechnen mit Napier


Die Rechenstäbe dienten in der ersten Rechenmaschine von Wilhelm Schickard zum Multiplizieren. Man liest öfters die Aussage, die Rechenstäbe seien ein Vorläufer des Rechenschiebers gewesen. Das ist nicht ganz richtig, weil die Rechenstäbe ein diskretes Rechenmittel sind und in keiner Weise Logarithmen enthalten. Im Grunde sind sie lediglich eine zersägte 1x1-Tabelle. Von der Entwicklung der Logarithmen an war es nur noch ein Schritt bis zu der Idee, Zahlen auf einer Strecke aufzureihen und sie ohne Umrechnung zu nutzen. Das machte ein gewisser Edmund Gunter erstmals 1620. Er erfand das eben erwähnte Lineal, die Gunter's Scale, die Lord Nelson noch bei der Schlacht von Trafalgar einsetzte, um Napoleons Admiral zu schlagen. Man brauchte nur die Längen abzugreifen und zu addieren, um eine Multiplikation auszuführen. Das machte man mit einem Stechzirkel, der zuvor in der Nautik genutzt wurde, um Entfernungen in Karten zu ermitteln.

Abbildung 1.7

Gunter's Scale und Zirkel als nautisches Messwerkzeug

35

1.4

1


Die nächste Verbesserung, die der Engländer William Oughtred bereits 1622 einführte, bestand darin, neben die erste Skala eine zweite, genau gleiche Skala zu legen und zum Rechnen einfach so zu verschieben, dass die Addition und damit die Multiplikation als Ergebnis direkt abgelesen werden konnte. Schließlich führte Seth Partridge 1654 die Zunge als in der Mitte verschiebbare Leiste beim Rechenschieber ein. So war es bereits 1654 möglich, einen Rechenschieber von einer Leistungsfähigkeit zu erwerben, wie es ihn bis etwa 1970 überall im Schreibwarenhandel zu kaufen gab.

Abbildung 1.8

Rechenschieber zum Errechnen von Schiffstonnagen (um 1820)

Wohl gemerkt, ein Rechenschieber ist eigentlich keine Rechenmaschine, sondern eher eine Art Zählhilfsmittel. Beim Einsatz eines Rechenschiebers rechnet ganz allein der Mensch; es gibt keine Kurbel, an der man drehen und mit deren Hilfe dann die Maschine etwas Eingestelltes »ausrechnen« könnte. Der Rechenschieber Der Rechenschieber war der Taschenrechner der vorelektronischen Zeit. Er war klein, handlich und schnell im Einsatz. In den technischen Berufen war er so weit verbreitet, dass er als Sinnbild für den Ingenieur stand. Sah man in einem Film einen Schauspieler mit einem Rechenschieber, wusste man, es handelt sich um einen Ingenieur, Techniker oder Architekten. Trotz seiner weiten Verbreitung hatte er gravierende Nachteile: Er war analog, daher ungenau, und das Ergebnis hing immer davon ab, wie gut er abgelesen wurde, also wie gut die Augen des Herrn Architekten etc. noch waren. Deshalb war der Läufer des Rechenschiebers wie eine Lupe gewölbt, so dass darunter die Skalen etwa zweifach vergrößert gesehen und einfacher abgelesen werden konnten (siehe Abbildung 1.9).

Der Rechenschieber macht lediglich aus einer einfachen Addition, die durch Verschieben zweier Skalen gegeneinander entsteht, mit Hilfe seiner Skaleneinteilung eine Multiplikation oder eine Division. Es gab auch Rechenschieber für Addition und Subtraktion. Aber diese waren im Grunde nichts anderes als ein Abakus, der mit Zahlstrecken statt mit Kugeln arbeitet, oder zwei Schullineale, die man gegeneinander verschiebt und dadurch Strecken addiert – demnach also ungenau, weil analog abzulesen. Im Gegensatz dazu ist der Abakus (siehe Abbildung 1.10) eine digitale Rechenhilfe, richtig genutzt, liefert er immer ganz exakte Ergebnisse. 36


Abbildung 1.9

Schul-Rechenschieber

Abbildung 1.10

Chinesischer Abakus

1.4.2

Der Abakus

Der Abakus ist mindestens 3.000 Jahre alt und wurde in China erfunden, von wo aus er nach Japan gelangte. Er war aber auch in der europäischen Antike bei Griechen und Römern bekannt. Während er bei uns nur noch als Kinderspielzeug dient, ist er in Asien vereinzelt noch heute in Gebrauch. Natürlich gibt es auch von diesem »Rechner« Computersimulationen. Eine besonders schöne ist die von David Bagley. Man findet sie auf der DVD unter: Software zum Buch\Kap01\abakus\wabacus-7.5.5\wabacus.exe Der chinesische Abakus hat zwei Bereiche. Auf jeder Stange befinden sich oben jeweils zwei weiße Perlen, in dem Feld darunter fünf schwarze. Von rechts nach links haben die Kugeln die in unserem Zehnersystem üblichen Werte. Wobei eine Perle oben für eine ganze Reihe unten steht, also für fünf.

37

1.4

1


Zum Rechnen schiebt man die Perlen zum dünnen Längsbrett zwischen den zwei Perlenarten. Man zählt also die schwarzen Perlen 1, 2, 3 ... (siehe Abbildung 1.11), und bei der Fünf schiebt man die schwarzen Perlen zurück und eine weiße zur Mitte. Die Abbildung zeigt die 1 mit dem chinesischen Abakus (mit zwei Nachkommastellen), also 1,00:

Abbildung 1.11

Die Eins, rechts daneben 0 Zehntel und Hundertstel

Wieder zählt man die schwarzen Perlen, bis die zweite weiße Perle verschoben werden kann. Zwei weiße Perlen in der Reihe werden zurückgeschoben und ergeben eine schwarze Perle in der folgenden Reihe. So ergeben eine weiße und vier schwarze Perlen in der Einerspalte sowie eine schwarze Perle in der Zehnerspalte die 19 (siehe Abbildung 1.12). Genau diese eine Eigenschaft ist es, die analoges von digitalem Rechnen unterscheidet. Sie ist so frappierend, dass wir heute im Grunde nur noch digital rechnen. Selbst bei der Zeit wird die analoge Anzeige immer mehr zu einer Art Referenz an vergangene Zeiten. Das Herz der Zeit schlägt digital. Selbst die Vorstellung von dem, »was die Welt im Innersten zusammenhält«, wandelt sich mehr und mehr zu einem digitalen Bild. Auch dazu hat Konrad Zuse einen vielbeachteten Beitrag geleistet. In seinem Buch »Rechnender Raum« beschreibt er seine Idee von einem »digitalen« Universum. Deshalb sollen diese beiden Techniken, ja Weltansichten, in einem eigenen Abschnitt erläutert werden.

38

Digital und analog

Abbildung 1.12

1.5

Abakus mit 19

Digital und analog

Was hat es also mit der digitalen und der analogen Technik genau auf sich?

1.5.1

Uhrenvergleich

Der Unterschied wird gerne anhand der Digital- und der Analoguhr deutlich gemacht. Bei der analogen Uhr ist es ein Zeiger, der über einem Ziffernblatt rotiert und zu einem bestimmten Zeitpunkt einen bestimmten Winkel über dem Ziffernblatt einnimmt. Bei welcher Zahl er dabei steht, ist allerdings stark vom Betrachter abhängig. Dieser entscheidet letztlich, es ist 17 Uhr 04, obwohl der Minutenzeiger bereits auf der 1 steht. Bei der Digitaluhr ist das ganz anders. Sie zeigt die Ziffern konkret an. Hier kann man nicht behaupten, es ist 17 Uhr 04, wenn die Uhr eine 17 und eine 05 anzeigt. Die Analoguhr zeigt kontinuierlich den Zeitablauf an und überlässt es dem Menschen, die konkrete Uhrzeit abzulesen und somit festzulegen (siehe Abbildung 1.13). Dass sich die Analoguhr trotz ihrer offensichtlichen Nachteile weiterhin behauptet, beruht auch darauf, dass sie die Zeit als teilbares Medium darstellt. Man sieht auf dem Zifferblatt nicht nur die aktuelle Uhrzeit, sondern auch, dass der Tag bereits zu Dreiviertel vergangen ist oder dass wir Mittag (High Noon), also die Hälfte des Tages hinter uns haben. Genau das kann man auf einer Digitaluhr nicht sehen, sie bietet uns nur nackte Zahlen. Die Uhr ist also nicht nur eine Scheibe mit Ziffern, sondern auch ein Tortendiagramm. Oder besser gesagt, Tortendiagramme sind so einsichtig, weil sie von unserer Uhr abstammen. 39

1.5


Abbildung 1.13

Analoguhr (Ziffernblatt einer Standuhr mit Mondphase)

Abbildung 1.14

Digitaluhr

© Mat neu; http://de.wikipedia.org

1

Bei einer Digitaluhr wird die Zeit ganz konkret durch Ziffern angezeigt. Solche Uhren sind keineswegs, wie man vielleicht denkt, eine Erfindung des Elektronikzeitalters. Die älteste heute noch laufende Digitaluhr stammt von 1599: die Uhr im Torre dell'Orologio – Uhrenturm – auf dem Markusplatz in Venedig (siehe Abbildung 1.15).

40

Quelle: http://de.wikipedia.org

Digital und analog

Abbildung 1.15

Die Digitalanzeige am Torre dell'Orologio in Venedig

Ein anderes Beispiel mit moderneren Technologien zeigt die Unterschiede zwischen analog und digital noch deutlicher.

1.5.2

LP versus CD

Als Thomas Alva Edison am 18. Juli 1877 den sogenannten Phonographen erfand, einen Vorläufer des Grammophons, übertrug er mechanisch die Luftschwingungen seiner Stimme auf eine Nadel, die sich entsprechend in eine rotierende Walze mit Staniolbeschichtung grub. Da die Schwingungen von der Frequenz der Stimme abhängen, sind sie sehr vielgestaltig, obwohl ihre technische Übertragung damals direkt geschah, also aus der Luft auf eine Membran und von dort auf die schreibende Nadel. Eine Verstärkung oder sonstige Änderung war nicht möglich. Trotz vieler technischer Verbesserungen bis zum modernen Schallplattenspieler blieb das Prinzip erhalten. Daher kann man auch mit etwas Übung anhand der Rillen erkennen, wo die Lieder auf einer LP beginnen und ob es temperamentvolle Stücke oder nur zarte Klänge sind (siehe Abbildung 1.16). Hohe Schwingungen haben als Rillen natürlich auch eine hohe Anzahl an »Kurven« auf einer kurzen Strecke und umgekehrt. Wenn man so will, sieht man die Schwingungen förmlich auf der Scheibe. Die Information über die Töne ist praktisch analog ihrer Form in der Luft auf der Platte verewigt, es findet keine umständliche Umrechnung von Zahlenwerten in Schwingungsgrößen statt.

41

1.5

1


Abbildung 1.16

Spurrillen in einer LP (stark vergrößert)

Ganz anders bei der CD. Auf ihr werden die Toninformationen digital gespeichert. Aus den Rillen sind zudem Flecken geworden (siehe Abbildung 1.17). Ihre Form hat nichts mehr mit Schwingungen zu tun, die man in die Luft überträgt. Sie sind eine Art winziger Höcker, die in zwei Formen vorkommen: einmal als Punkte, die man Pits nennt, und als längliche Hügelchen, die als Lands bezeichnet werden. Zwischen den Pits und Lands liegen jeweils verschieden große Lücken, die zwar nichts aussagen, aber die Zahl der gespeicherten Bits bestimmen.

Abbildung 1.17

CD-Oberfläche (unbeschichtet und stark vergrößert)

Um die gespeicherten Töne hörbar und die Daten lesbar zu machen, müssen die Informationen umgerechnet werden. Nun könnte man meinen, ein Pit sei eine 0 und ein Land eine 1. Dem ist aber nicht so, die Bits entsprechen eigentlich den Lücken, denn wenn ein Wechsel stattfindet – beispielsweise von Pit nach Land oder umgekehrt –, zählt die Lücke als 1. Findet kein Wechsel statt, folgt also auf Land wieder ein Land oder auf ein Pit ein weiteres Pit, so zählt die Lücke als 0.

42

Digital und analog

Das könnte beispielsweise so aussehen: P = Pit L = Land L__P__L__P __L__ P__ L__ P__ P__ P__ P__ L__ L__ L__ L__ L 1

1

1

1

1

1

1

0

0

0

1

0

0

0

0

Nicht nur, dass ein CD-Player diese Lücken entsprechend ermitteln muss, das Ergebnis ist lediglich eine Zahlenreihe binärer Zahlen. Aus diesen Zahlen müssen in der Musikanlage Töne, im Blue-ray-Player Filme und im Computer Texte, Bilder und Filme berechnet werden. Weil die Information binär gelesen werden muss, wird bei all diesen Geräten die gewünschte Information von einer Art ganz speziellem Computer gewonnen. Er rechnet die binären Zahlen mit speziellen Algorithmen in Töne und Bilder um. Diese Computer nennt man DAUs. Das steht keineswegs für »dümmster anzunehmender User«, den jeder aus den Computerwitzen kennt, sondern für Digital-Analog-Umsetzer. Bekannte Begriffe sind außerdem Digital-Analog-Wandler oder Analog-Digital-Wandler.

Abbildung 1.18

Analoges Signal (Tonsignal im Programm WavePad Soundeditor)

Ein weiterer Vorteil der digitalen Technik ist die Sicherheit vor Qualitätsverlusten. Bei analogen Signalen (siehe Abbildung 1.18) kann es jederzeit zu Qualitätsverlusten kommen. Auch ist es kaum möglich, auftretende Verluste rückgängig zu machen. Das kommt allein schon daher, dass analoge Signale praktisch jeden denkbaren Pegel annehmen können. Digitale Signale dagegen haben fest defi-

43

1.5

1


nierte Pegel (siehe Abbildung 1.19). Das bedeutet, die Information wird dadurch übertragen, dass ein Signal zwei verschiedene Zustände einnimmt, wobei die beiden Pegel nicht exakt eingehalten werden müssen. Ein digitaler Signalinterpreter kann mit Grenzwerten arbeiten; das Überschreiten eines Wertes bedeutet, das Signal steht für eine 1 und alles unterhalb des Wertes für eine 0.

Abbildung 1.19

Digitales Signal

Eine Verstümmelung des Pegels bei digitalen Signalen bedeutet daher noch lange keinen Qualitätsverlust. Die Information baut auf zwei Signalpegeln auf, die für die binären Werte 0 und 1 stehen. Man kann ein undeutliches digitales Signal so lange korrigieren, wie die Pegel unterschieden werden können. Außerdem ist es möglich, digitale Signale mit Hilfe mathematischer Verfahren zu schützen, beispielsweise indem man Quersummen über Datenpakete bildet. Kommt es zu Datenverlusten, lassen sich so gezielt Pakete erneut anfordern.

Abbildung 1.20

Gestörtes digitales Signal

Diese Eigenschaft der digitalen Signalverarbeitung ist einer der entscheidenden Gründe für den Erfolg der Computer und aller damit zusammenhängenden Techniken. Bereits Konrad Zuse trug zu diesem Erfolg bei, indem er sich beim Bau des ersten Computers für die Nutzung der binären Zahlen entschied. Digitale Produkte, die davon profitieren, dass es keine Qualitätsverluste gibt, sind Blue-ray, DVD, CD, Computer, ISDN, DSL usw.

44

Digital und analog

Die Frage nach analog und digital ist also gar nicht so trivial, wie sie auf den ersten Blick aussieht. Wie bereits erwähnt, fand das neue digitale Denken auch Eingang in Naturwissenschaft und Philosophie. Seit Newton war man der Meinung, die Welt sei eine analoge »Maschine«, die beliebige Zustände annehmen kann. Die moderne Physik ist jedoch inzwischen davon überzeugt, dass das nicht so ist. Als Beweis müssen die sogenannten Quanten herhalten, kleine Lichtteilchen. Sie sind ausschlaggebend bei den Zuständen, die Atome annehmen können. Auch hier gibt es keine Zwischenzustände, die Natur macht also Sprünge. Der Satz »Natura non facit saltus« (Die Natur macht keine Sprünge) stammt eigentlich von Carl von Linné, dem Herrn, der das Leben unseres Planeten katalogisiert und untergliedert hat. Den Sinn dieses Satzes findet man bereits bei Aristoteles, der ihn zur Grundlage des Naturverständnisses bis ins 20. Jahrhundert werden ließ. Seit der Quantentheorie gilt er allerdings als widerlegt.

1.5.3

Zwischen digital und analog und zwischen wahr und falsch

Als Grundbestandteil einer analogen Maschine können wir uns Räder denken. Ihre Drehbewegung erlaubt einen endlosen Lauf, der sich auch umkehren lässt. Die Position dieser Räder ist allerdings nie wirklich exakt zu bestimmen. Sie arbeiten anlog, das heißt, sie kennen beliebige Zwischenstellungen zwischen den Positionen, die sie einnehmen können. Grundbausteine digitaler Maschinen sind dagegen Schalter, die verschiedene Stellungen einnehmen können. Hier ist es allerdings so, dass es gar keine Zwischenstellungen gibt. Die Schalter springen immer von einer Position in die nächste oder vorige. Es gibt keine Positionen dazwischen. Es gab Versuche, die Vorteile der analogen Welt auf die digitale Welt zu übertragen. Denn die digitale Technik hat trotz all der vielen gravierenden Vorteile auch ein paar fundamentale Nachteile. Ein Nachteil ist, dass die Natur zwar im ganz Kleinen, also im Quantenbereich als digital angesehen werden kann, im Bereich unserer alltäglichen Umwelt jedoch ist sie durchweg analog und stetig. Somit gibt es hier nicht nur Ja/Nein-Entscheidungen, sondern in der Mehrzahl sogar Kompromisse, ein »Vielleicht«, ein »Wahrscheinlich« oder ein »Eventuell«. Das lässt sich jedoch mit dem Computer nur sehr schlecht verarbeiten. Er kennt eben keine Positionen dazwischen, wie sie ein Zeiger an einer Uhr ständig einnimmt. Aus diesem Grund wurden verschiedene Verfahren entwickelt, die sozusagen einen analogen Rechner simulieren. Eines dieser Verfahren ist die sogenannte Fuzzy-Logik. Diese Fuzzy-Logik ist kein triviales Thema, und wer sich ernsthaft

45

1.5

1


damit auseinandersetzen möchte, sollte viel Zeit mitbringen und mathematisch beschlagen sein. Eine kurze Einführung soll es hier trotzdem geben. Die Idee, die hinter der Fuzzy-Logik steckt, ist schon sehr alt. Bereits die Philosophen der Antike hatten sich darüber entzweit. Platon war der Meinung, dass zwischen der Aussage Wahr und Falsch ein drittes Feld des Vielleicht lag. Aristoteles, sein Schüler, sah dagegen ganz streng mathematisch keinen Platz für etwas Drittes und formulierte das Gesetz vom ausgeschlossenen Dritten, das unser logisches Denken bis in 20. Jahrhundert hinein prägte. Für ihn gab es nur die beiden Aussagen wahr und falsch. Wenn etwas nicht wahr war, war es falsch, etwas anderes gab es nicht. Erst die Mathematik und damit die Datenverarbeitung der jüngsten Zeit stieß wieder auf die Probleme des »vielleicht«, des »nicht ganz« oder »eventuell doch«. Bereits 1965 veröffentlichte Prof. L. A. Zadeh die Fuzzy-Set-Theorie, die sogenannte unscharfe Mengenlehre. Statt der Zugehörigkeit eines Elementes x zu einer Menge M gibt es in der Fuzzy-Set-Theorie eine Zugehörigkeitsfunktion für jedes Element x. Sie bestimmt, wie stark x zu einer bestimmten Menge gehört. Es gibt im Internet eine ganze Reihe interessanter Seiten, die sich mit dem Thema Fuzzy-Logik auseinandersetzen. Für Java-Kenner enthält die Buch-DVD eine kleine Fuzzy-Demo, die sich jFuzzyLogic nennt (Software zum Buch\Kap01\Noch mehr Spaß\jFuzzyLogic_2.0.6.jar). Nachdem sich die Fuzzy-Logik in der Informatik zu etablieren begann, wurde sie in erster Linie in Japan genauer erforscht und in zahlreichen Anwendungen realisiert. Ein Grund für die Fuzzy-Begeisterung der Japaner war die U-Bahn von Sendai. Geplant war sie schon seit 1965, der Baubeginn war allerdings erst 1983. Die Zugsteuerung wurde von der Firma Hitachi entwickelt. Sie integrierte eine Automatik, die den Zug selbsttätig beschleunigt und abbremst. Damit dies ruckfrei geschieht, verwendete man die damals neue Fuzzy-Logik. So kam es in Japan zu einer regelrechten Fuzzy-Welle, die allerdings nur teilweise auf die übrigen Industrienationen überschwappte. In Japan gab es Waschmaschinen und Trockner mit Fuzzy-Steuerung, Videokameras, die mit Fuzzy-Logik das Bild stabilisierten, und vieles mehr. Das soll aber nicht heißen, dass die Fuzzy-Logik heute nicht mehr eingesetzt wird. Doch der Begriff hat seine Zugkraft für die Werbung längst eingebüßt. Deshalb steht schon lange nicht mehr Fuzzy drauf, wo überall Fuzzy drin ist. Die Einsatzgebiete der Fuzzy-Logik sind heute in erster Linie Unterhaltungselektronik, aber auch Kameras jeder Art, Regelungstechnik, medizinische Geräte, Kfz

46

Lesen Sie weiter

und andere Fahrzeuge, Fertigungsautomatisierung und künstliche Intelligenz mit den Bereichen Objekt- und Spracherkennung. »Ein Computer arbeitet nur mit Nullen und Einsen – aber irgendwie entsteht oft der Eindruck, es sind mehr Nullen als Einsen am Werk.« – Onno Ehlers (*1969), Produzent & Autor

1.6

Lesen Sie weiter

Webseiten zum Kapitel URL

Beschreibung

http://www.rosenkranzgebete.de/

christliche Grundlagen zum Rosenkranz

www.liborius.de/unser-glaube/ der-rosenkranz

Aufbau des Rosenkranzes

www.dieglasvitrine.de

Homepage der Glaskünstlerin Biggi Lehrl

http://www.benjaminwrightson.de/abakus/ Rechnen mit dem Abakus abakus.htm http://www.edumedia-sciences.com/de/ a584-abakus

Abakus-Simulation (kostenpflichtig)

http://www.tux.org/~bagleyd/abacus.html

David Bagleys Abakus-Seite

http://www.sliderulemuseum.com/

Rechenschieber-Museum

http://www.dazine.de/Schieber.html

Rechenschieber-Simulation

http://de.wikipedia.org/wiki/ Napiersche_Rechenst%C3 %A4bchen

Napierrechenstäbe bei Wikipedia Infos über Napierstäbe bei Wikipedia

http://www.henked.de/begriffe/ algorithmus.htm

Napierstäbe und Abakus

http://www.math.tu-berlin.de/aktMath/ site/themen_musik.html

Wie viel Musik passt auf eine CD?

http://jfuzzylogic.sourceforge.net/html/ index.html

Fuzzy-Beispiel im Web

http://www.omega.com/techref/ fuzzylogic.html

engl. Erläuterung zur Fuzzy-Logik

http://cs.uni-muenster.de/Studieren/ Scripten/Lippe/wwwFuzzyScript/fssim.html

Fuzzy-Simulator

http://www.fuzzy-logic.com/

engl. Fuzzy-Logik-Handbuch

47

1.6

1


Literatur zum Kapitel Zöller-Greer, Peter: Künstliche Intelligenz. Composia Verlag 2007 Beauclair, Wilfried de: Rechnen mit Maschinen: Eine Bildgeschichte der Rechentechnik. Springer, Berlin 2007

48

»Hätte Gott bei der Erschaffung der Welt schon einen Computer gehabt, wäre alles sehr viel teurer geworden. Schon weil er die Kosten hätte errechnen können.« – Anonymus Rechenmaschinen gab es bereits in der antiken Literatur. Platon, Herodot und andere berichten davon. Doch viele Jahre glaubte man, die alten Beschreibungen seien nur Konstruktionen in der Phantasie der großen griechischen Mathematiker ohne reale Gegenstücke gewesen. Bis ein Perlentaucher vor einer kleinen griechischen Insel etwas mit nach oben brachte, was die Sicht auf die Ingenieure der Antike radikal ändern sollte.

2

Computer ohne Programme

300 v. Chr.

150 v. Chr.

0

ca. 800

1630

2000

Antikythera Räderuhren

mech. Rechenmaschinen

2.1

Die ersten Rechenmaschinen

Wie klares Quellwasser erfrischte diese frühherbstliche Nacht des 20. September 331 vor Christi Geburt die Lagernden in der Ebene, unweit von Gaugamela. Friedlich schaute der Mond mit seinem vollen Gesicht von einer dünnen Wolken-

49

2


bank zu den Persern hinab, die lärmend ihr Lager für die kommende Nacht bereiteten. Pferde wurden gestriegelt, Elefanten erhielten ihr letztes Futter für diesen Tag, und Schwerter und Lanzen wurden nachgesehen und geschärft. Da hallten aufgeregte Schreie durch das Heer des Darius. Der Mond hatte seine runde Form verloren. Von Minute zu Minute mehr wechselte seine Farbe von fahlem Gelb ins Rötliche. Stunden ruhte das gewaltige Heerlager in dunklem Schweigen. Verängstigte Gesichter raunten mit leisen Stimmen die schlimmsten Befürchtungen. Es war das Warnsignal für eine nahende Katastrophe. Großkönig Darius wusste schon Tage vorher von diesem kosmischen Schauspiel. Seine Hofastronomen zählten zu den besten »Wissenschaftlern« der damaligen Welt. Aber der unumschränkte Herrscher über das größte Reich der Erde hielt es nicht für nötig, seine sklavengleichen Söldner über solche Dinge unterrichten zu lassen. Ganz anders die Makedonier Alexanders, die gerade mühsam den Tigris durchquert hatten. Sie erwarteten voller Spannung das Himmelsschauspiel. Alexander hatte tags zuvor bereits den Gottheiten Nyx (Nacht), Erebos (Finsternis), den Erdgöttinen Gaia und Demeter sowie Uranos, dem Gott des Himmels, ebenso wie Artemis und Selene, den Mondgöttinen, geopfert. Für ihn hatte sein Seher Aristander die kommende Verfinsterung des Mondes errechnet. Der Mann, der bereits die Geburt Alexanders vorhergesagt hatte, war gleichermaßen begabt als Kenner des Sternenhimmels wie als Promoter überzeugender Kulthandlungen. Aristanders Heimatstadt, Telmessus in Karien (dem heutigen Fethiye), war damals so etwas wie ein Zentrum der Wahrsagekunst. Wenn der reißende Tigris sie beim Überqueren nicht Tage gekostet hätte, wäre man genau in dieser Nacht bereit gewesen, über die Perser herzufallen. Viele waren sich einig, in dem aufkommenden Chaos und der unbändigen Furcht vor den Göttern, die solche Zeichen an den Himmel setzten, wären die Perser ohne Gegenwehr davongelaufen. War es nicht in der berühmten Schlacht von Halys (am 28. Mai 585 v. Chr.) genau so gekommen? Damals hatte sich über den kämpfenden Kriegern die Sonne verfinstert, genau wie der große Seher Thales von Milet es vorhergesagt hatte. Daraufhin hörte das Gemetzel auf und man schloss Frieden, die Götter hatten deutlich genug gezeigt, dass ihnen dieses Schlachten missfiel. Die Berechnung von Sonnenfinsternissen ist weit schwieriger als die von Mondfinsternissen, zumal dabei der Schatten des Mondes nur als schmaler Streifen über die Erde läuft, während der Schatten der Erde, der den Vollmond verdunkelt, von überall gleich auf den Mond fällt. Trotzdem war man in der Antike bereits in der Lage, beide Ereignisse ziemlich genau vorherzusagen, teilweise sogar fehlerfrei zu berechnen. Das gelang, wie man heute weiß, unter anderem auch durch den Einsatz der ersten Rechenmaschinen.

50


2.1.1

Die Maschine von Antikythera

1900, kurz vor Ostern, zwang ein Unwetter ein paar Schwammtaucher mit ihrem Kutter, des Nachts an den Gestaden von Kythera und Antikythera Schutz zu suchen. Am nächsten Morgen, als die Wolken sich verzogen hatten, wollte man vor dem Aufbruch die flachen Gewässer nach Schwämmen absuchen. Dabei entdeckte man ein Schiffswrack aus der Antike. Kleine Götterstatuen, Münzen und zahlreiche Gebrauchsgegenstände wurden später von offizieller Seite geborgen. Einige Fundstücke, bronzene Fragmente, blieben lange Zeit unbeachtet. Erst Jahre später stellte sich heraus, dass es Bruchstücke von Zahnrädern, also Teile des Getriebes einer Maschine waren. Erst dachte man an ein Gerät, das im Mittelalter zufällig verloren gegangen und unter die Fundstücke des antiken Schiffes gelangt war. Doch langwierige Untersuchungen und Forschungen lieferten die Erkenntnis, dass es ein antikes Gerät zur Bestimmung der Konstellation von Sonne, Mond und Planeten war. Damit veränderte die Maschine von Antikythera das Bild, das man sich von der antiken Welt gemacht hatte, total. Selbst Erich von Däniken befasste sich intensiv mit diesem Gerät, nicht ohne den Verdacht zu äußern, dass wieder einmal Außerirdische ihre Hand im Spiel gehabt hätten.

© Marsyas; http://de.wikipedia.org

Inzwischen steht fest, Maschinen, selbst Automaten, gab es bereits in der Antike. Existierten sie zum großen Teil auch nur als Anleitungen oder Beschreibungen in der damaligen Literatur, so gab es doch auch bereits hochkomplizierte Konstruktionen. Sie wurden in erster Linie, sofern es keine Kriegsmaschinen waren, dazu genutzt, den Menschen ins Staunen zu versetzen. So gab es sich selbst öffnende Tempeltüren, sich bewegende Statuen und die ersten mechanischen Uhren. Selbst Rechenwerke existierten bereits, wie der Fund des Antikythera-Mechanismus eindeutig belegt.

Abbildung 2.1

Hauptbruchstück des Antikythera-Mechanismus

51

2.1

2


Die erstaunliche Maschine ist ein Überrest aus einem im Jahre 80 v. Chr. gesunkenen Schiff – vom ersten Eindruck her ein verkrusteter Klumpen, an dem man gerade mal ein Zahnrad vermuten konnte, wenn man die Phantasie dazu aufbrachte. Bis sich um 1970 der amerikanische Wissenschaftshistoriker Derek de Sollo Price mit dem »Haufen Rost« auseinandersetzte. In einer ersten Rekonstruktion stellte er fest, dass das ursprüngliche Gerät aus einer etwa 206 x 164 x 480 mm großen Holzkiste bestand. Auf ihr gab es wohl auch Skalen, die zur Anzeige von Werten mit Hilfe von Zeigern dienten. Durch ein Röntgenbild mit Gammastrahlen fand er in dem Klumpen etwa 30 Zahnräder aus Bronze. Im Herbst 2005 wurde der Mechanismus von drei Universitäten einer weiteren Analyse unterzogen. Es stellte sich heraus, dass wahrscheinlich über die Hälfte der Zahnräder verloren gegangen war, dass der ganze Apparat wohl aus einem Getriebe mit etwa 70 Zahnrädern bestanden hatte und mit einer Handkurbel angetrieben wurde. Außerdem fand man etwa 2.000 Schriftzeichen auf den Holzresten. 12 Zahnräder Zahnräder sind Hauptbestandteil aller mechanischen Rechenmaschinen – durchaus ein Grund, sich diese Antriebsräder des Maschinenbaus einmal genauer anzusehen. »Zahnräder sind Mathematik aus Eisen.« Wer sich ein wenig mit Zahnrädern auseinandergesetzt hat, wird dem beipflichten. Aber woher stammen sie und warum sind sie so wichtig? Wie wir selbst feststellen konnten, waren sie bereits in der Antike bekannt und wurden sogar für komplizierte Mechaniken genutzt. Nach der Erfindung des Rades und damit der Achse in der Steinzeit konnten Drehbewegungen vielseitig genutzt werden – ob es die Fortbewegung mit Karren oder der Einsatz von Göpeln1 für erste Maschinenantriebe war. Und doch galt es zwei große Schwierigkeiten zu meistern. Einmal hatte man nur die vorhandene Drehgeschwindigkeit, und die Drehkraft musste immer exakt am Ort ihrer Verwendung erzeugt werden. Es gab keine Möglichkeit, die Drehzahl zu verringern oder zu erhöhen, und die Kraft ließ sich nicht an andere Stellen übertragen. Setzte man zwei Räder aufeinander, änderten sich die Drehrichtung und die Geschwindigkeit abhängig von der Größe der Räder. Die Räder mussten jedoch fest aufeinandergepresst sein, damit der sogenannte Kraftschluss die Kräfte übertragen konnte und kein Schlupf 2 auftrat.

1 Laufrad/Rosswerk – Vorrichtung zur Nutzung der Bewegungsenergie von Tier und Mensch. Oft als große Version eines Hamsterlaufrads. Wurde früher in Bergwerken und in der Landwirtschaft viel genutzt. 2 Durchrutschen von Rädern bei Kraftschluss

52


Damit war es möglich, Kräfte über kürzere Strecken zu verlagern. Ein Riemen, gleich welcher Art, erlaubte größere Abstände zwischen den Rädern. Aber auch hier trat der Schlupf auf. Mit solchen »Getrieben« ließen sich keinerlei Uhren oder gar Rechenmaschinen aufbauen. Der auftretende Schlupf machte aus den gewünschten Ergebnissen Zufallserscheinungen. Deshalb wurde schon früh das Zahnrad entwickelt. Bei ihm tritt an die Stelle des Kraftschlusses der Formschluss. Am drehenden Rad sorgen feste Formen, die in andere Formen des Gegenrades eingreifen, dafür, dass sich die Räder in jedem Fall drehen. Überhöhter Widerstand führt zum Zerbrechen der Räder, stehen bleiben können sie nicht. Was für Formen es sind, ist im Grunde gleich – ob Zapfen in dem einen Rad, die in Schlitze in dem anderen eingreifen, ob die Räder nur geriffelt sind oder ob sie eine sogenannte Evolventenverzahnung haben, die eine exakt berechnete Abrollkurve besitzen. Das ist im Grunde gleich, wichtig ist nur, dass sich die Formen während der Drehung ständig berühren und dass das Spiel nicht so groß ist, dass die Zähne überspringen können, was dem Schlupf bei den Reibrädern entspricht. Diese Eigenart, der sogenannte Formschluss, und die damit verbundene schlupffreie Übertragung von Drehungen, erlaubte es den Erfindern über zwei Jahrtausende, Rechengeräte und später Uhren mit Zahnrädern zu bauen.

© The Antikythera-Mechanismus Research Project

Zum Vergleich: Eine normale Uhr mit Stundenanzeige hat etwa 15 Zahnräder. Die Differenzmaschine nach Babbage bestand aus etwa 8.000 Teilen, von denen etwa 2.000 Zahnräder waren (siehe Abbildung 2.2).

Abbildung 2.2

Modell des sogenannten Antikythera-Mechanismus

53

2.1

2


Der Antikythera-Mechanismus (siehe Abbildung 2.2) soll angeblich die Bahnen der fünf damals bekannten Planeten sowie der Sonne und des Mondes berechnet und angezeigt haben. Selbstverständlich konnte man mit ihm auch eine Mondfinsternis vorherberechnen. Es ist nicht zu vermuten, dass der Seher Aristander bereits über eine solche Maschine verfügte. Der Einsatz eines Vorgängermodells ist aber durchaus denkbar. In jedem Fall begleitete er Alexander während der Eroberung Ägyptens und lernte die Sternkunde dieser Kultur kennen, wie er auch noch nach dem Sieg bei Gaugamela mit der Sternenkunde der Babylonier Bekanntschaft machen durfte. Neben Rechengeräten mit Zahnradgetrieben wären aber auch Rechentafeln denkbar. In jedem Fall ist er in der Lage gewesen, die Finsternis vorherzusehen, und hat damit den Ausgang der Schlacht und somit den Lauf der Welt beeinflusst. Mechanische »Computer«, wenn wir einen dem Antikythera-Mechanismus ähnlichen Apparat so nennen wollen, hatten also von Anfang an eine große Bedeutung. Und der Antikythera-Mechanismus war fast eine Art tragbarer Rechner, der den Vorteil besaß, dass man selbst auf Reisen innerhalb kurzer Zeit hochkomplexe astronomische Berechnungen durchführen konnte, was nicht nur bei Kriegszügen von enormer Bedeutung sein konnte. Zumindest konnte man damit die aktuelle Zeit, wahrscheinlich sogar die Position eines Schiffes genau bestimmen. Was aber nicht heißen soll, dass die Griechen bereits über genaue Seekarten verfügten. Aber man konnte auf diese Weise bekannte geografische Punkte ansteuern. Wer an die Odyssee des Dichters Homer denkt, weiß, dass man sich nach solchen Orten, Inseln und Ähnlichem richtete. Mit einer astronomischen Maschine konnte man genau feststellen, in welche Richtung man segeln musste, um von einem bestimmten Ort zu einem anderen bekannten Hafen zu gelangen, und sich so bei längeren Reisen orientieren. Natürlich lässt sich all das mit unseren modernen Computern nachvollziehen. Simulationen der Antikythera-Maschine sind zwar möglich, bringen aber wegen der fehlenden astronomischen Kenntnisse für den Laien relativ wenig. Außerdem sollte man nicht vergessen, dass diese Maschine nicht einmal von der Forschung vollständig verstanden wird, zumal ein großer Teil der Mechanik unwiederbringlich verloren gegangen ist. Trotzdem wollen wir uns das einmal ansehen. Eine funktionierende Simulation des Apparates für Etoys findet man unter: http:// www.spinellis.gr/sw/ameso/ Von der Webseite kann man sich ein funktionierendes Simulationsprogramm des Antikythera-Apparates herunterladen oder sich die Funktionsweise anhand von

54


YouTube-Videos genauer anschauen. Auch auf der DVD befindet sich das entsprechende Programm. Praxis: Die Antikythera-Maschine simulieren Um die Simulation der Antikythera-Maschine auf dem heimischen PC ausführen zu können, müssen Sie zunächst das Etoys-Softwaresystem unter dem von Ihnen genutzten Betriebssystem installieren. Sie finden Etoys auf der Buch-DVD unter Software zum Buch\Kap02\Etoys. In diesem Unterverzeichnis liegt das Etoys-System in den verschiedenen Ausführungen sowie die Antikythera-Simulation Antikythera.045.pr. Zur Installation unter Windows starten Sie die Datei Etoys4-Final-Win.exe. In einem ersten Schritt bestätigen Sie die Lizenz für das System.

Abbildung 2.3

Etoys-Lizenz bestätigen

Wählen Sie nun das Verzeichnis, in dem Etoys installiert werden soll.

Abbildung 2.4

Verzeichnis für Etoys festlegen

55

2.1

2


Jetzt bestimmen Sie den Namen, unter dem Etoys im Menü angezeigt werden soll.

Abbildung 2.5

Ordnernamen für Menü festlegen

Im letzten Schritt wird Etoys auf dem Rechner installiert.

Abbildung 2.6

Etoys wird installiert.

Ist das System installiert, können Sie die Simulation mit einem Doppelklick auf die Datei Antikythera.045.pr starten. Ersatzweise kann sie auch vom laufenden System aus gestartet werden. Dazu gehen Sie an den oberen Rand des Etoys-Fensters, woraufhin eine Leiste eingeblendet wird. Das Ordnersymbol mit dem nach oben weisenden Pfeil (Finde ein anderes Projekt) erlaubt das Starten von Programmen. Suchen Sie im Dateibaum (siehe Abbildung 2.7) links das Verzeichnis auf der Buch-DVD (Software zum Buch\Kap02\Etoys), und wählen Sie das Programm Antikythera.045.pr aus. Durch einen Klick auf die Schaltfläche Laden wird es gestartet. 56


Ein kleines Dialogmenü enthält die verschieden Ansichten der Zahnräder sowie Mondphasen und -finsternisse (siehe Abbildung 2.8).

Abbildung 2.7

Simulation aus Etoys starten

Um diese Simulation vollständig zu verstehen, müssten wir uns freilich intensiv mit Astronomie auseinandersetzen. Die Simulation stammt von dem Athener Prof. Diomidis Spinellis, der den Antikythera-Mechanismus jahrelang untersucht hat. Eine Erläuterung findet man im Internet unter: http://www.spinellis.gr/pubs/jrnl/2008-Computer-Antikythera/html/ Spi08d.htm#_ftn1 Auch wenn wir die tieferen Zusammenhänge im Getriebe des Apparates nicht verstehen, so sehen wir doch, wie komplex diese antike Maschine ist und wie viel Know-how bereits damals vorhanden war (siehe Abbildung 2.8). Zumal dem Konstrukteur vor fast 2.000 Jahren vieles von dem heutigen Wissen und den heutigen technischen Möglichkeiten fehlte, um in der Lage zu sein, eine solche analoge Rechenmaschine herstellen zu können. Man kann vor dieser Leistung nur den Hut ziehen! Bleibt nur noch zu erwähnen, dass Etoys ein Programmiersystem für Kinder ist, das auch Teil der Softwareausstattung des 100$ Computers wurde. Das System scheint vom ersten Eindruck her recht einfach, was jedoch täuscht. Es baut auf der objektorientierten Programmiersprache Smalltalk auf und erlaubt die Entwicklung anspruchsvoller Programme.

57

2.1

2


Abbildung 2.8

2.1.2

Antikythera-Mechanismus-Simulation mit Etoys

Die Sterne lügen nicht

Natürlich war mit der Maschine von Antikythera die Entwicklung der astronomischen »Rechner« noch lange nicht am Ende angelangt. Ein Höhepunkt ihrer Entwicklung stellten die astronomischen Uhren dar. Es gibt in Europa eine ganze Reihe dieser technischen Wunderwerke, die im Einzelfall bis auf den heutigen Tag funktionsfähig sind. Selbst die schönsten Exemplare, wie beispielsweise die Uhr am Ulmer Rathaus (siehe Abbildung 2.9), können ihre Verwandtschaft mit dem Antikythera-Mechanismus nicht ganz verheimlichen. Wer schon einmal in eine dieser Räderuhren hineingesehen hat, weiß, dass sie verschieden große Zahnräder besitzen, die durch ihre Übersetzungsverhältnisse in der Lage sind, bestimmte Himmelsereignisse modellhaft anzuzeigen. Selbst eine einfache Uhr – ohne jede Sonderanzeige – ist nichts anderes als ein Zeitmessgerät, das den astronomischen Tag in zwei gleiche Teile zerlegt, indem der Stundenzeiger an einem halben Tag einen Vollkreis durchläuft. Wie eine astronomische Uhr aufgebaut ist, erläutert der Uhrmachermeister Roland Wyss anhand der von ihm gebauten astronomischen Uhr auf einer Webseite im Internet: http://www.zeitzentrum.ch/uploadfiles/DE_100023.pdf. Das Dokument beschreibt die Idee und Funktionsweise eines wunderschönen Modells einer astronomischen Uhr. Doch das Erstaunlichste daran ist: Betrachtet man ihr Inneres, findet man tatsächlich Ähnlichkeiten mit den Rädern der Maschine von Antikythera (siehe Abbildung 2.10). 58

Quelle: http://www.astrouhr.telebus.de/bilder/AstroUhrQuadrat.jpg


Astronomische Uhr am Ulmer Rathaus

© Roland Wyss

Abbildung 2.9

Abbildung 2.10 Das Innere der astronomischen Uhr des Schweizer Uhrmachermeisters und Uhrenrestaurators Roland Wyss

59

2.1


Wer sich mit mechanischen Uhrwerken ein wenig auseinandersetzt, stellt rasch fest, dass der Bau einer solchen Uhr auf der Lösung zweier Probleme fußt: Es geht einmal darum, die Verhältnisse der Bewegungen von Himmelskörpern zu simulieren. Dazu müssen Drehbewegungen mit verschiedensten Geschwindigkeiten ausgeführt werden. So etwas erreicht man durch Zahnräder, deren Größe sich nach den gewünschten Geschwindigkeiten richtet. Das zweite, durchaus nicht geringere Problem ist die Kontinuität der Bewegung. Die Maschine von Antikythera wurde wahrscheinlich mit einer Handkurbel angetrieben. Stellte man sie auf eine bestimmte astronomische Konstellation ein, konnte man sie so weit weiterdrehen, bis man die Zielkonstellation erreichte und wusste, wie viele Tage bis dorthin vergehen würden. Den Ablauf der Zeit konnte man damit, wie bei der Sand- oder Sonnenuhr, nicht messen. Dazu hätte man etwas benötigt, das dafür sorgte, dass die Drehbewegung über einen längeren Zeitraum immer mit der gleichen Geschwindigkeit erfolgt. Der menschliche Arm ist dazu nicht in der Lage, somit kann dieses Problem nur durch einen mechanischen Antrieb und mit Hilfe spezieller physikalischer Effekte gelöst werden. Schon im Mittelalter fand man heraus, dass man eine rasche Drehbewegung mit dem sogenannten Waaggang hemmen konnte und die Bewegung dadurch gleichbleibend schnell ablief. Das geschah durch einen Waagbalken, der um eine senkrechte Achse schwang und mit zwei »Fingern« in das sogenannte Kronrad griff. Durch Gewichte, die sich auf dem Waagbalken wie bei einer Balkenwaage verschieben ließen (daher der Name Waaggang), konnte man die Laufgeschwindigkeit der Uhr beeinflussen. Auch wenn der Waagbalken im Grunde ein waagerecht schwingendes Pendel ist, ist er wesentlich ungenauer.

© Paul Gerber

2

Abbildung 2.11

60

Waagbalkenuhr ganz aus Holz


Das erste richtige Pendel findet man im »Codex Madrid« von Leonardo da Vinci in einer seiner zahllosen Konstruktionszeichnungen. Doch erst Galileo Galilei soll knappe 80 Jahre später erkannt haben (1581), dass die Schwingungen eines Pendels extrem regelmäßig sind. Somit war die Grundlage für die Pendeluhr gelegt, die man heute noch in zahlreichen Wohnzimmern finden kann.

Abbildung 2.12 Pendeluhr von Ebele als Eckuhr mit Sekundengangwerk, Ankerhemmung, Lyrapendel und Mondphase

Der Unterschied zwischen Waaggang und Pendel ist der, dass ein Pendel Energie absorbiert, in Lageenergie umwandelt und sie kontinuierlich, durch die Erdbeschleunigung angetrieben, wieder abgibt. Die Reibung, die unweigerlich zum

61

2.1

2


Auspendeln führen würde, wird dadurch ausgeglichen, dass die Ankerhemmung dem Pendel jedes Mal einen kleinen Stoß versetzt. Die dafür nötige Energie stammt, wie die Energie für die Drehung des Räderwerks, von den langsam abwärts laufenden Gewichten. Mit diesen mechanischen Finessen hat die Idee zur Maschine von Antikythera ihre perfekte Ausformung zum Uhrwerk gefunden. Der Aufbau des Räderwerks simuliert dabei die Bewegung der Gestirne, zumindest die der Sonne und oft auch des Mondes. Der Antikythera-Mechanismus simulierte sogar die Bewegung aller damals bekannten Planeten. Er war sozusagen ein miniaturisiertes Planetarium. Diese Vision der alten Griechen führte nicht nur zur modernen, astronomischen Räderuhr (siehe Abbildung 2.10), sondern auch zu den Planetarien, die alle heute bekannten Planetenbahnen und eine Vielzahl der Fixsterne an einen künstlichen Himmel projizieren und damit den Nachthimmel simulieren – auf ihre Art eine Form von Himmelscomputern.

2.2

Planetarien simulieren mit Stellarium

Nach so vielen analogen Rechenwerken wird es nun aber Zeit, zum digitalen Computer zurückzufinden. All diese Instrumente der vordigitalen Ära kann man heute mit der Universalmaschine »Digitalcomputer« nachempfinden. Nun mag es zwar ganz witzig sein, das Räderwerk einer antiken Uhr mit dem Computer zu simulieren (siehe Abbildung 2.1), interessanter ist es jedoch zu sehen, wie sich der moderne Computer als Gerät zur Himmelsbeobachtung und damit zur Himmelssimulation bewährt. Sozusagen als heimisches Planetarium. Es gibt eine ganze Reihe guter Simulationsprogramme für den Sternenhimmel, die den heimischen Rechner in ein kleines Miniplanetarium verwandeln. Nur wenige sind jedoch so gut wie Stellarium (http://www.stellarium.org). Stellarium ist sozusagen die Krone der Entwicklung, die mit dem Mechanismus von Antikythera begann. Durchaus professionellen Ansprüchen gerecht werdend, gibt es sogar ein Projektionsgerät dafür, um im kleinen Rahmen ein echtes Planetarium zu betreiben. Auf dem heimischen PC stellt das Programm ein virtuelles Planetarium dar, bei dem die Sterne nicht projiziert, sondern als Punkte auf dem Monitor dargestellt werden. Programmiert hat es der Franzose Fabien Chéreau. Es ist für die drei wichtigsten Betriebssysteme (Linux, Mac OS X und Windows) erhältlich. Außerdem gibt es eine freie Java-Version, mit der man gut nachvollziehen kann, wie ein derartiges Programm erstellt wird. Stellarium wurde unter die GNU-Lizenz gestellt und ist damit frei verfügbar.

62


Das Programm zeigt am Himmelszelt nahezu 600.000 Sterne, und zwar so, wie sie sich in der Natur zeigen oder auch heller. Man kann die Bewegung der Himmelskörper im Zeitraffer beschleunigen und astronomische Konstellationen früherer Tage nachstellen. Natürlich ist es vor allem für Hobbyastronomen interessant, die mit diesem Programm ihre Himmelsexkursionen vorbereiten können. Dafür können Himmelsausschnitte realitätsnah vergrößert und damit auch kleinere Sterne sichtbar gemacht werden. Die Grundausstattung zeigt alle Objekte, die mit bloßem Auge, einem Fernglas oder einem kleinen Fernrohr gesehen werden können. Der Sternkatalog kann jedoch ergänzt werden, und zwar bis zu Sternen der 15ten Größenklasse. Das entspricht der Lichtstärke größerer astronomischer Fernrohre, so dass selbst Berufs-Astronomen Nutzen aus dem Einsatz des Programms ziehen können. Beeindruckender für den Laien ist die Fähigkeit, Himmelsphänomene wie Meteore, Nebel, Galaxien, Sonnen- und Mond-Auf- und Untergänge sowie Verfinsterungen realitätsnah darstellen zu können. Die Sternbilder können angezeigt und ihre Veränderung durch die Wanderung der Fixsterne über die Jahrtausende simuliert werden. Daher ist Stellarium genau das richtige Programm zum Überprüfen der Ergebnisse, die vor über 2.300 Jahren wahrscheinlich schon mit den ersten »Rechenmaschinen« Griechenlands vorausberechnet wurden. Um mit dieser »Zeitmaschine« einen Blick in die Ebene von Gaugamela am Abend des 20. September 331 vor Christi Geburt zu werfen, muss Stellarium allerdings programmiert werden. Dazu besitzt es eine sogenannte ScriptEngine, einen Interpreter für JavaScript, entsprechend der ECMAScript-Spezifikation. Diese ScriptEngine wurde erst vor wenigen Monaten erneuert und ist deshalb nicht unbedingt ausgereift oder fehlerfrei. Genauso wie beim Programm selbst, das sich ebenfalls noch in einem frühen Entwicklungsstadium befindet, sollte man keine zu hohen Ansprüche stellen und über diese oder jene Fehlfunktion hinwegsehen. Praxis: Die wichtigsten Skriptbefehle der Stellarium-ScriptEngine 왘

core.setJDay (<double Tage>)

Eingabe des Datums als julianisches Datum. Das julianische Datum ist ein reines Tagesdatum, das die Tage abzählt, die seit dem l. Januar –4712 (4713 v. Chr.) 12:00 Uhr vergangen sind. Es gibt ein Jahr 0, weshalb der Starttag nach unserer Zeitrechnung im Jahre –4712 eigentlich im Jahr 4713 v. Chr. liegt. 왘

core.getJDay (void)

Liefert das aktuelle julianische Datum.

63

2.2

2


왘

core.setDate (" ", " ")

Setzt die aktuelle Zeit. Der Zeitpunkt wird als Textkonstante in folgender Form angegeben: 2009-08-11T10:27:35, also als Jahr-Monat-TagTStunden: Minuten:Sekunden. Die gewünschte Zeit kann aber auch relativ eingestellt werden. Dazu gibt man als Textkonstante den Zeitraum zur Zielzeit an, z. B. »+ 2 years«. Als Einheiten können genutzt werden: seconds, minutes, hours, days, weeks, months, years. Die Konstante now lässt sich verwenden, um den aktuellen Zeitpunkt anzugeben. Die Zielzeit kann auch durch mehrere setDate-Befehle eingestellt werden, wobei man absolute Angaben durch relative Angaben ergänzen kann. Eine absolute Zeitangabe vor der Zeitrechnung durch Minus-Zeichen lässt sich nicht einstellen. 왘

core.setTimeRate (<double sec>)

Gibt den Zeitrafferwert in Sekunden an. Das ist die Zeit, die bei der Simulation in einer Sekunde verfließen soll. 왘

core.getTimeRate (void)

Liefert die aktuell eingestellte Zeitrate zurück. 왘

core.wait (<double sec>)

Wartet den festgelegten Zeitraum in Sekunden. 왘

core.waitFor ("".. " ")

Wartet bis zum angegebenen Zeitpunkt, der in der üblichen Schreibweise (siehe core.SetDate) wiedergegeben wird. 왘

core.selectObjectByName (, )

Wählt das benannte Objekt aus. Mit dem zweiten Parameter lässt sich über true oder false der Objektcursor aktivieren, wodurch das Objekt mit Strahlen markiert wird. 왘

core.clear ()

Neuaufbau der Anzeige mit der angegebenen Konfiguration. natural aktiviert die Landschaft, die Atmosphäre und das Sternenzelt azimu-

tal, starchart nur die Sterne mit einer äquatorialen Montierung. 왘

core.setObserverLocation (<double Längengrad>, <double Breitengrad>, <double

Höhe>,

<double

duration=l.>,

,)

Der Längengrad wird als Erstes angegeben. Östliche Bereiche sind Pluswerte. Die Angabe muss zwischen –180 und 180 liegen. Beim Breitengrad ist der Norden positiv. Auch hier muss der Wert zwischen –180 und 180 liegen. Die Höhe wird nicht als Winkelhöhe, sondern als »Flughöhe« in Metern angegeben. Der Wert muss größer als –1.000 sein. Mit dem duration-Zahlenwert

64


wird eine Geschwindigkeit für die Bewegung vom vorigen zum neuen Ort festgelegt. 왘

core.setObserverLocation (", <double duration=1.>)

Legt die Position des Beobachters fest. Als Name kann ein Ort angegeben werden, der sich in der Datenbank befindet. Mit dem duration-Zahlenwert wird die Geschwindigkeit für die Ortsänderung bestimmt. 왘

core.screenshot (< "Dateiname ">, , )

Der Befehl erstellt eine Grafikdatei von der aktuellen Sicht in Stellarium. Nach dem Dateinamen kann mit true oder false angegeben werden, ob die Sterne schwarz auf weiß oder weiß auf schwarz gespeichert werden. Als Letztes kann das Verzeichnis festgelegt werden. 왘

core.setHideGui (< "true/false ">)

Macht die Bedienelemente sichtbar oder unsichtbar. 왘

core.setMinFps (floatAnzahl) core.setMaxFps (floatAnzahl)

Diese Funktionen setzen Minimum und Maximum-Anzahl der Animationsgeschwindigkeit. 왘

core.loadSound (< "Dateiname ">, < "SoundID ">)

Auf diese Weise kann man eine Sounddatei laden und ihr eine Kennung zuweisen, mit der sie gestartet und gestoppt werden kann. 왘

core.playSound (< "SoundID ">)

Hiermit kann ein geladener Sound mit Hilfe der Kennung gestartet werden. 왘

core.pauseSound ()

Diese Funktion bewirkt das Pausieren eines laufenden Sounds mit Hilfe der Kennung. 왘

core.stopSound ()

Auf diese Weise kann ein geladener Sound mit Hilfe der Kennung abgebrochen werden. Das Erstellen von Skripten ist recht einfach. Nachdem der Quellcode mit einem Editor geschrieben wurde, speichert man ihn mit der Endung ssc im Verzeichnis stellarium/scripts3 ab. Im Programm kann das Skript folgendermaßen aufgerufen werden: 왘

Bewegen Sie die Maus an den linken Rand, und zwar unterhalb der Mitte. Ein Seitenmenü schiebt sich ins Bild. In diesem wählen Sie das Icon mit dem Schraubenschlüssel (Einstellungsfenster).

3 Näheres dazu im folgenden Absatz.

65

2.2

2


왘

In dem sich nun öffnenden Dialog können Sie im oberen Menü Skripte auswählen. Sie sehen nun links die Liste der Skripte und können nach der Auswahl mit dem Start-Button das Skript starten.

Auf der Homepage des Programms findet man einige Beispiele, die einem zeigen, wie es geht. Versuchen wir uns also einmal als Aristander: Reisen wir zurück in das Heer des unsterblichen Alexander und sehen uns den Himmel des 20. September 331 an, so wie ihn Tausende Makedonier ehrfurchtsvoll ansahen und verängstigte Perser anstarten. Nur wenige Stunden danach waren viele von ihnen tot. Das sollten wir uns vergegenwärtigen, während wir unser kleines Himmelsprogramm zusammentippen (siehe Abbildung 2.6). Wir haben das Aristander-Programm beispielhaft auf der DVD beigefügt, Sie finden es unter Software zum Buch\Kap02\Stellarium\Scripts\lunar_total_Gaugamela.ssc. Um es laden zu können, müssen Sie es in das Script-Verzeichnis von Stellarium kopieren. Das Verzeichnis befindet sich im Installationsverzeichnis von Stellarium, beispielsweise: C:\Program Files\Stellarium\scripts.

2.3

Rechenuhr, Dampfrechner und Superautomaten

In einem Punkt unterscheiden sich Computer und Antikythera-Maschine gravierend: Der Computer ist eine digitale Maschine, und der griechische Himmelsapparat ist eine analoge Apparatur. Was man darunter versteht, wurde bereits in Kapitel 1, »Von Rosenkranz und Rechenschieber«, im Abschnitt »Digital und analog« ausführlich erläutert. Von den technischen Voraussetzungen her hätte man auch in der Antike mechanische digitale Rechengeräte bauen können. Analog antreiben hätte man sie trotzdem müssen. Auch elektrische Geräte – selbst wenn sie digital arbeiten – haben Signalverläufe und Ströme, die man als analog ansehen kann. Entscheidend ist eben nur die Betrachtungsweise. Prinzipiell kann man aber mit Zahnrädern und Zeigern genauso gut einen Computer bauen wie mit digitalen Bauteilen. Es gab in der Geschichte der Rechengeräte daher ganze Generationen mechanischer Rechenmaschinen – wobei mechanisch nicht auch analog heißt. Selbst so frühe Maschinen wie die sogenannte Pascaline besaßen nicht etwa Ziffernblätter, auf denen das Ergebnis ungefähr angezeigt wurde, sondern kleine Fenster, in denen die Ziffern des Ergebnisses standen, wenn die Berechnung abgeschlossen war. 66


2.3.1

Schickards Rechenmaschine

Die erste Rechenmaschine, von der wir wissen, ging im Dreißigjährigen Krieg beim Brand des Hauses von Prof. Wilhelm Schickard verloren. Er lehrte an der Universität Tübingen Hebräisch und Astronomie und erwähnte diese Maschine 1623 in einem Brief an Johannes Kepler. In einem seiner Notizbücher finden sich auch Skizzen, die Aussehen und Funktionsweise zeigen, außerdem erwähnte er noch, dass er diese Maschine auch gebaut habe. Mehr ist von der ersten Rechenmaschine nicht bekannt. Außer der Rechenmaschine hatte er ein winziges Planetarium konstruiert, das man in der Hand hielt und mit einer Kurbel in Bewegung setzte, wenn man so will, eine Antikythera-Maschine ohne Skalen. Auf einem Gemälde aus jener Zeit hält er es in der rechten Hand (siehe Abbildung 2.14), was die Bedeutung zeigt, die er selbst dieser Erfindung beimaß. Für uns ist es der rote Faden, der von der Antikythera-Maschine zur ersten Rechenmaschine führt. Seine Rechenmaschine konnte addieren und subtrahieren. Mit zusätzlich angebrachten Napierrechenstäben konnte man multiplizieren und dividieren. Somit war Schickards Maschine ein Vierspeziesrechner, weil man die vier Grundrechenarten damit durchführen konnte. Maschinen, die nur addieren und subtrahieren können, nennt man Zweispeziesmaschinen. Sein eigenes Schicksal endete nicht weniger tragisch als das seiner Rechenmaschine. 1634, nach der Schlacht von Nördlingen, besetzten die kaiserlichen katholischen Truppen Tübingen. Sie brachten nicht nur Willkür und Despotismus mit, sondern auch die Pest. Innerhalb von zwei Jahren starben Schickards Frau und all seine Kinder an der Pest. Er selbst starb am 23. Oktober 1635 ebenfalls an dieser furchtbaren Seuche. Praxis: Simulation von Schickards Rechenmaschine Mit dem Computer kann man die erste Rechenmaschine recht einfach wieder zum Leben erwecken. Es gibt mehrere Webseiten, die sich mit Schickards Rechenmaschine auseinandersetzen. Eine sehr interessante Seite ist die folgende: http://www.henked.de/begriffe/algorithmus.htm#Schickard. Auf dieser Seite gibt es auch eine JavaScript-Simulation der Schickardschen Rechenmaschine, mit der man so rechnen kann, wie es der Astronom Schickard vor fast 400 Jahren in Tübingen auf seiner Maschine konnte. Die miteinander zu multiplizierenden Zahlen werden ganz oben und ganz unten eingestellt. Es wird eine Stelle nach der anderen des einen Multiplikators mit den Napierschiebern eingestellt und die Zahlen darauf, wie bei den Napierstäbchen üblich und ab der Stelle, die man bearbeitet, auf die Ergebniszeile addiert, indem man die Drehschalter entsprechend der Ergebniszahl dreht. Schon wird das Ergebnis in der Mitte angezeigt. 67

2.3


Abbildung 2.13

Schickardmaschine als JavaScript-Simulation

Daher ist die Maschine ein Apparat, der Multiplikationen auf Additionen reduziert, und daher sozusagen eine Art digitaler Rechenschieber. Leider wurde der Apparat erst 1957 zum ersten Mal rekonstruiert (siehe Abbildung 2.15). Er war also für die ganze Zeit davor verloren gewesen. Wäre er damals nicht in Schickards Haus verbrannt, hätte man ihn gewiss weiterentwickelt, und mechanische Rechner dieser Bauart – also »digitale Rechenschieber« – hätten eine weite Verbreitung gefunden.

© Herbert Klaeren; http://de.wikipedia.org

2

Abbildung 2.14

68

Prof. Schickard auf einem zeitgenössischen Gemälde

© Herbert Klaeren; http://de.wikipedia.org


Abbildung 2.15

Nachbau von Schickards Rechenmaschine

© Lothar Spurzem; http://de.wikipedia.org

Schaut man sich einen der letzten mechanischen Vierspeziesrechner an, also einen Rechner, wie er vor 50 Jahren wirklich verwendet wurde, so mag man trotz der Unterschiede Ähnlichkeiten feststellen (siehe Abbildung 2.16), obwohl die Mechanik eine ganz andere ist. Sie ist eher mit den Rechnermodellen verwandt, die wir uns im Folgenden anschauen werden, wie etwa der Pascaline. Der gezeigte moderne Vierspeziesrechner ist eine Brunsviga, die 1956 für einen Preis von 975,– DM im Handel erhältlich war.

Abbildung 2.16

Moderner Vierspeziesrechner Brunsviga von 1956

69

2.3

2


2.3.2

Die Pascaline

Nachdem die Konstruktion des Prof. Schickard verloren ging, machten sich andere große Mathematiker Gedanken um Apparate, die ihnen das Rechnen erleichtern konnten. Einer dieser großen Männer war Blaise Pascal. Er wurde am 19. Juni 1623 in Clemont Ferrand geboren und starb am 19. August 1662 in Paris. Er wurde von seinem hochgebildeten Vater selbst unterrichtet, weil er aus Gesundheitsgründen keine Schulen besuchen konnte. Bereits als Jugendlicher löste er komplexe mathematische Probleme und wuchs zu einem der größten Mathematiker aller Zeiten heran. Jeder sollte noch aus der Schule den Begriff des Pascalschen Dreiecks kennen, der auf ihn zurückgeht. Es sind die sogenannten Binomialkoeffizienten, die man in Dreiecksform anordnen kann, um sie leichter bestimmen zu können. Pascal nutzte das Dreieck in einer Abhandlung zur Wahrscheinlichkeitstheorie. Obwohl es schon lange vor ihm bekannt war, wurde es 1730 nach ihm benannt. Als sein Vater 1640 oberster Steuereinnehmer der Normandie wurde, erfand Blaise Pascal für ihn eine Zweispeziesrechenmaschine, die sogenannte Roue Pascal4 oder Pascaline (siehe Abbildung 2.17). Sie gilt heute als die älteste noch erhaltene mechanische Rechenmaschine der Menschheit. Pascal ließ etwa 50 Stück davon produzieren, neun Exemplare existieren noch. Da sie langwierig in Handarbeit hergestellt wurden, waren sie unbezahlbar teuer, und sein Traum von einer lukrativen Fabrik für mechanische Rechner blieb unerfüllt.

Quelle: http://www.lamef.bordeaux.ensam.fr/~jlc/ASI/Historique/histo.html

Abbildung 2.17

Pascaline

Die ersten Versionen waren lediglich in der Lage zu addieren. Weitere Modelle konnten schließlich auch subtrahieren. Das Addierwerk war selbst für die damalige Zeit relativ einfach aufgebaut, aber sehr robust (siehe Abbildung 2.18). 4 Pascal-Rad.

70


Quelle: http://www.lamef.bordeaux.ensam.fr/~jlc/ASI/Historique/histo.html

Abbildung 2.18

Pascaline geöffnet

Praxis: Simulation der Pascaline Natürlich gibt es auch eine Simulation der Pascaline, man findet sie im Netz unter folgender URL: http://pagesperso-orange.fr/therese.eveilleau/pages/truc_mat/textes/ pascaline.htm. Sie zeigt, wie die Überträge bei diesem Rechner realisiert wurden. Der erste Computer war ... ein Mensch! Gerade in jener Zeit, als man den ersten mechanischen Rechner baute, wurde ein neuer Begriff in die englische Sprache aufgenommen, der einmal ein ganzes Zeitalter prägen sollte: Es war das Wort »Computer«. Der Engländer Sir Thomas Brown benutzte den Begriff »Computer« für einen Mathematiker, der langwierige Kalenderberechnungen durchführte, 1646 zum ersten Mal.

2.3.3

Morlands Apparate

Blaise Pascal hatte bewiesen, dass man Rechenvorgänge mit mechanischen Geräten vereinfachen konnte – eine Entwicklung, die in den wissenschaftlichen Kreisen sehr schnell bekannt wurde. So verwundert es nicht, dass sich bald viele große Geister daran versuchten, ebenfalls Rechenmaschinen zu entwickeln. Eine der schillerndsten Figuren dieser Zeit war zweifellos Sir Samuel Morland. Er war Doppelagent, Diplomat, Ingenieur für Wasserkunst5, Feuerwerker, Erfinder von Pumpen und der Vorläufer unserer heutigen Verbrennungsmotoren, aber auch von Rechenmaschinen. Dieser universelle Geist lebte von 1625 bis 1695, 1660 wurde er aufgrund seiner Leistungen geadelt. 5 So nannte man die Hebung und Förderung von Wasser (hauptsächlich im Bergbau).

71

2.3


Drei völlig unterschiedliche Rechenmaschinen soll er entwickelt haben. Neben einer Vierspeziesmaschine, die als erste der Welt angesehen wird, baute er einen Rechner für trigonometrische Berechnungen und einen Rechner für die Addition von englischen Geldbeträgen aus Pence, Shillings und Pounds. Er gilt als erster Rechner für ein nichtdezimales Zahlensystem.


2

Abbildung 2.19

2.3.4

Sir Samuel Morland

Leibniz' Rechenmaschine

Der nächste große Name unter den Erfindern von Rechenmaschinen ist ein gewisser Gottfried Wilhelm Leibniz (1646–1716). Er war wie Samuel Morland ein universeller Geist, aber im Gegensatz zu ihm ein reiner Theoretiker, dafür aber einer der ganz Großen. Leibniz hat im Grunde auf allen Gebieten, auf denen er geforscht hat, Bahnbrechendes geleistet – er gilt daher als letztes großes Universalgenie. Befähigt war er dazu unter anderem, weil er die Welt und alle Wissenschaften als Einheit sah. Als Philosoph entwickelte er die sogenannte Monadologie, befasste sich mit Determination und Erkenntnistheorie. Auch Fragen zur Existenz Gottes hat er diskutiert. Der Satz von der besten aller möglichen Welten stammt von ihm. In der Physik verdankt ihm die Dynamik einige Erkenntnisse. Mit einem seiner Bücher begründete er die Paläontologie und hatte erste Vorstellungen von einer Evolution der Tierarten. Als Mathematiker hat er die Differenzial- und Integralrechnung entwickelt und – das sollte uns ganz wichtig sein – die

72



binären Zahlen in die Mathematik eingeführt. Außerdem zeigte er, wie man mit diesen Zahlen logische Zusammenhänge, nämlich durch die Bewertung als wahr und falsch, darstellen und verarbeiten kann.

Abbildung 2.20

Gottfried Wilhelm Leibniz

Im Innern seiner Rechenmaschine fand bereits eine solche Umwandlung statt. Angezeigt werden konnten jedoch nur dezimale Zahlen. Die Rechenmaschine war indes so anspruchsvoll konstruiert, dass man heute bezweifelt, ob es zu Lebzeiten des Erfinders fehlerfrei arbeitende Exemplare seiner Maschinen gab. 1990 wurde von Nikolaus Joachim Lehmann ein Modell rekonstruiert, das fehlerfrei arbeitet. Leibniz entwickelte zwei Bauelemente, die Staffelwalze und das Sprossenrad, die beide bis zum Schluss wichtige Bestandteile in mechanischen Rechenmaschinen waren. Die Staffelwalze (siehe Abbildung 2.21) realisiert bei Multiplikationen den sogenannten Zehnerübertrag6. Es handelt sich dabei um einen Zylinder mit verschieden vielen Zähnen an unterschiedlichen Positionen. Die Zahl der funktionsfähigen Zähne entspricht der Zahl, mit der gerechnet wird. Ein kleines Zahnrad lässt sich entlang der Walze verschieben und greift die entsprechende Anzahl beim Drehen der Staffelwalze ab. 6 Erhält man bei Berechnungen Werte größer 10, muss der Zehnerwert zur nächsten Stelle zugeschlagen werden. Man spricht von »im Sinn behalten«. Das ist der sogenannte Zehnerübertrag.

73

2.3


ZH T

ÜA

SR ZR

VU

ZE

EG ER SW EA

Abbildung 2.21

Quelle: http://curta.de/kr35/index.htm

2

Staffelwalze (SW) eines Curta-Rechners

Das Sprossenrad hat Leibniz selbst nicht realisieren lassen. Es findet sich jedoch als Ideenskizze in seinem Nachlass. Beim Sprossenrad (siehe Abbildung 2.22) werden bewegliche Zähne entsprechend der eingestellten Zahl vorgeschoben und damit zum Eingriff gebracht. Bei dem Modell in der gezeigten Abbildung sitzt das Sprossenrad hinten. Mit dem Knebel oben stellt man die gewünschte Zahl ein. Die dadurch herauskommenden Bolzen sind auf dem Foto in dem Ring darunter schwach sichtbar. Dreht man nun das Sprossenrad mit der Kurbel, wird das vordere Rad entsprechend weitergedreht und zeigt so die eingestellte Zahl an. Durch weiteres Drehen kann man neu eingestellte Zahlen zur ersten hinzuaddieren. Wem das Ganze etwas zu theoretisch ist, der kann sich eine Simulation ansehen, die einen Blick in den Leibnizschen Rechner darstellt. Man findet sie auf der DVD des Buches unter Software zum Buch\Kap02\Leibniz\Leibniz.avi. Bei diesem virtuellen Leibniz-Rechner ist die Staffelwalze selbst verschiebbar und in der Animation auf die Vier eingestellt. So wird bei jedem Rechenschritt vier addiert. Die Animation läuft bis 16, so dass man gut sehen kann, wie der Übertrag realisiert wird.

74

© self; http://de.wikipedia.org


Abbildung 2.22

Modell eines Sprossenrads

Abbildung 2.23

Rechenmaschine von Leibniz

75

2.3


2.3.5

Von Leibniz’ Zeit in die Gegenwart: Brunsviga, Superautomat und Co.

Was nun folgte, war eine stete Weiterentwicklung bis zu Maschinen wie der Brunsviga, die in Abbildung 2.16 bereits vorgestellt wurde. Es gab schließlich wahre Rechenmonster, die statt mit einer Kurbel von einem Elektromotor angetrieben wurden, oft noch mit Druckwerken ausgestattet, um die Berechnungen sauber zu Papier zu bringen. Als Beispiel soll hier ein älteres Modell dienen, der Superautomat von Rheinmetall-Borsig aus dem Jahre 1931 (siehe Abbildung 2.24), eine Vierspeziesmaschine. Sie arbeitete mit einer Staffelwalze, die von einem Elektromotor mit 500 U/min angetrieben wurde. Sie besaß einen Speicher mit Rückübertragung in das Summierwerk, wodurch man Reihenrechnungen durchführen konnte. Bis 1957 wurde sie gebaut und kostete ursprünglich 3.200 Reichsmark.

© technikum29

2

Abbildung 2.24

Der Superautomat SAL von Rheinmetall

Man sollte nicht unterschätzen, wie lange diese Maschinen in Gebrauch waren. So, wie man auf chinesischen Märkten bis vor kurzem noch den Einsatz des Abakus erleben konnte, so gab es auch noch lange Enklaven für mechanische Rechenmaschinen. Noch gut kann ich mich an einen Abend im Jahre 1978 erinnern: Die Erfindung des Taschenrechners lag schon zehn Jahre zurück. In jener Nacht überschritt ich

76


die Grenze zur Tschechoslowakei in Marktredwitz, es galt die geforderten Valuta umzutauschen. Das kleine Zimmer war voller Menschen, und die Dame von der Grenzkontrolle rechnete und rechnete. Es war ein kleiner tonnenförmiger Rechner, der Brunsviga nicht unähnlich. Es galt zwar stets den gleichen Multiplikator zu nutzen, aber die Tage des Aufenthalts mussten immer wieder neu eingestellt werden. Dann war mindestens eine Umdrehung erforderlich, bis das Ergebnis abgelesen werden konnte. Die arme Frau war Kandidatin für eine akute Sehnenscheidenentzündung. Von einem Taschenrechner, wie ich ihn im Gepäck hatte, konnte sie nur träumen. Mechanische Rechner hatten nun einmal die Schwierigkeit, dass man nicht nur die erforderlichen Zahlen einstellen musste, sondern man musste den Rechenvorgang auch durchführen können. Meist war dies mit dem Drehen einer Kurbel verbunden. Trotzdem war es oft nicht ganz einfach, weil es zahlreiche Tasten und Hebelchen gab. Die Curta hatte beispielsweise einen Nullstellhebel, der das Zählwerk auf Null zurückstellte. Praxis: Kurbelgetriebene Rechenmaschine Natürlich möchte ich meinen Lesern die Chance geben, das Erlebnis dieser Nacht nachzuempfinden und auch einmal eine kurbelgetriebene Rechendose dieser Bauart zu bedienen. Man findet sie im Internet: http://www.curta.de/kr34/ curta_simulator_en.htm.

Abbildung 2.25

Simulator einer Curta-Rechendose von Jan Meyer

77

2.3


Die Bedienung war bis auf den Umstand, dass man zum Rechnen kurbeln musste, nicht ganz einfach. Ausführliche Anleitungen findet man deshalb auf folgender Webseite: http://www.curta.de/kr34/index.htm. Rechner mit Bargeldfach: die Registrierkasse Die Betrachtung der mechanischen Rechner kann man nicht abschließen, ohne ihren häufigsten Vertreter nicht wenigstens genannt zu haben: die Registrierkasse. Sie wurde 1879 von dem Lokalbesitzer James Ritty aus Dayton in Ohio erfunden, damit seine Barkeeper ihn nicht mehr ständig betrogen. Später verkaufte er seine Firma für Registerkassen an John H. Patterson, der sie in National Cash Register (NCR) umtaufte. NCR wurde später ein bekannter Computerhersteller. Registrierkassen sind im Grunde ein Addierwerk mit integrierter Geldschublade (siehe Abbildung 2.26). Obwohl relativ spät erfunden, dominierten sie bald sämtliche Läden und Theken. Es gibt sie bis heute, allerdings in Form von modernen Computerkassen.


2

Abbildung 2.26

2.3.6

National-Registrierkasse von 1900

Der Taschenrechner

Im Unterschied zu den gerade erwähnten mechanischen Rechnern haben elektronische Taschenrechner lediglich Tasten, die der direkten Bedienung dienen. Man gibt nur noch die Zahlen ein und bestimmt die Rechenvorgänge oder fordert das Ergebnis an. 78


Diese kleinen elektronischen Helfer gibt es inzwischen in den unterschiedlichsten Bauformen. Jeder von uns kennt sie oder hat sogar mehrere davon in der Schublade. Millionenfach produziert, stehen sie fast jedem Menschen überall zur Verfügung.

Abbildung 2.27

Moderner Vierspeziesrechner: Taschenrechner mit Solarzellen

Wie die mechanischen Rechenmaschinen, die von ihnen abgelöst wurden, so sind auch unsere modernen Taschenrechner keine Computer im eigentlichen Sinn. Während ein Computer ein sogenannter universeller Automat ist, sind Taschenrechner nur für Berechnungen ausgelegt7; meist sind es Vierspeziesrechner, so wie der Erste seiner Art von Schickard. Während ein Computer mit Hilfe der entsprechenden Software sogar dazu gebracht werden kann, uns einen Taschenrechner vorzugaukeln (siehe Abbildung 2.28), können Taschenrechner eben nur rechnen8. Computer sind eben viel mehr als nur Vierspeziesrechner. Auch, wenn Leibniz bereits ahnte, dass man mit den binären Zahlen mehr machen kann als nur addieren, war ihm die Idee des Computers noch fremd. Erst von Neumann und Turing erkannten um 1940 die universelle Verwendbarkeit von Computern in ihrer ganzen Breite. Die Idee vom echten Computer ist schon etwas älter. 7 Wir haben bereits in Kapitel 1, »Von Rosenkranz und Rechenschieber«, gesehen, dass der Windows-Taschenrechner in der wissenschaftlichen Ansicht noch einiges mehr kann. 8 Es gibt für spezielle Berechnungen programmierbare Modelle. Echte Computer sind es trotzdem nicht.

79

2.3

2


Abbildung 2.28

Taschenrechner von Windows Vista in Normalansicht

Lehrer zu einem seiner Schüler: »Computer heißt eigentlich Rechner.« Schüler: »Was!?« – Aus einer Schülerzeitung

2.4

Die Analytische Maschine

Den ersten echten Computer, der noch mit Zahnrädern laufen sollte, entwickelte ein gewisser Charles Babbage (engl. Gelehrter, 1791–1871; siehe Abbildung 2.29). Allerdings scheiterte damals seine Realisierung.

2.4.1

Babbages Idee

Unter der Analytischen Maschine verstand Babbage eine im Sinne von Turing vollständige Rechenmaschine, auch wenn er Turing (1912–1954) selbst natürlich noch nicht kennen konnte. Nach der Difference Engine (siehe Abbildung 2.30), einer Maschine, die lediglich addieren und subtrahieren konnte, wollte er eine Maschine bauen, die sämtliche Rechenvorgänge beherrschen sollte. Man sollte sie dazu beliebig programmieren, also voreinstellen können, bevor man den eigentlichen Rechenvorgang in die Wege leitete. Diese Analytical Engine würde damit weit mehr können als nur rechnen. Außerdem sollte sie vollautomatisch sein, also keineswegs von menschlicher Muskelkraft, sondern von einer Dampfmaschine angetrieben werden.

80



Charles Babbage

Abbildung 2.30

Babbages Difference Engine


Abbildung 2.29

Die universelle Verwendbarkeit stellte bereits Lady Ada Lovelace fest, seine Mitarbeiterin, schrieb sie doch: »Wenn zum Beispiel die grundlegenden Beziehungen zwischen Tönen aus der Harmonie- und Kompositionslehre einer solchen Darstellung zugänglich wären, könnte diese Maschine sorgfältig erarbeitete und wissenschaftliche Musikstücke von beliebiger Komplexität oder Länge komponieren.«9 9 Quelle: Eugene Eric Kim und Betty Alexandra Toole: Ada und der erste Computer. Spectrum der Wissenschaft 7/1999. S. 80. http://www.spektrum.de/artikel/825569& z=798888

81

2.4



2

Abbildung 2.31

Augusta Ada King Byron, Countess of Lovelace, die erste Programmautorin

Sie sah sozusagen die heutige »Computermusik« voraus und erkannte die Transformationsfähigkeit der Information. Aufmerksam geworden war sie auf den ersten Computer, weil sie eine Übersetzung machen musste: Ein Offizier hatte in Turin einen Aufsatz über die analytische Maschine verfasst. Allerdings sah die erste Programmiererin der Welt auch sehr gut die Grenzen des nie gebauten Apparates: »Die Analytische Maschine besitzt keinerlei schöpferische Fähigkeiten«, stellte sie fest. »Sie kann lediglich genau das tun, was wir ihr aufzutragen verstehen.«10 So hat sie im Grunde auch die Grenzen der Turingmaschine11 erkannt und hätte einen ersten Turingtest formulieren können. Dieser Turingtest ist von Bedeutung, wenn es zu entscheiden gilt, was ein Computer kann und was er nicht kann. Beides, Turingmaschine wie Turingtest, gehört zur theoretischen Informatik. 10 Dito. 11 Eine theoretische Universalmaschine und der denkbar einfachste Computer (später mehr dazu).

82


Adas Übersetzung kann man heute natürlich auf dem Computer nachlesen, und zwar mit Hilfe des Internets, von dem die kluge Frau noch nichts erahnen konnte: http://www.fourmilab.ch/babbage/Osketch.html. Sie hatte den Text mit eigenen Ideen so erweitert, dass er am Ende doppelt so lang geworden war. Augusta Ada King Byron, Countess of Lovelace Ada war die Tochter des berühmten Dichters George Gordon Noel Lord Byron, den sie nie kennenlernte, da ihn ihre Mutter kurz nach ihrer Geburt für immer verließ. Von ihrer Mutter, die Geometrie und Astronomie studiert hatte, erbte sie ihr Faible für die Mathematik. Die Mutter ermöglichte ihr auch ein naturwissenschaftliches Studium, in dem sie Charles Babbage und die Mathematikerin Mary Somerville kennenlernte, eine der berühmtesten Wissenschaftlerinnen ihrer Zeit. Mit 19 heiratete sie William King, den späteren Earl of Lovelace. Da sie ihre Ehe als unglücklich empfand, suchte sie ständig Ablenkung, die sie in Affären und Pferdewetten fand. Sie starb bereits im Alter von 36 Jahren nach langer Bettlägerigkeit an Krebs. Berühmt geworden ist sie unter anderem auch wegen ihrer Beschäftigung mit den Rechenmaschinen von Charles Babbage. Nachdem sie 1843 eine Bedienungsanleitung und eine Beschreibung für dessen Maschine aus dem Italienischen ins Englische übersetzt hatte, erstellte sie eine Anleitung dazu, wie man Bernoulli-Zahlen mit der Maschine berechnen könnte. Aus diesem Grund gilt sie als erste Programmiererin der Welt, und man benannte 1983 eine neue Programmiersprache nach ihr, Ada.

Praxis: Babbages Maschine Natürlich ist Babbages Maschine auch mit dem Computer simuliert worden. Dafür gibt es ein Java-Programm auf der beiliegenden DVD. Man findet es unter Software zum Buch\Kap02\Analytic Engine\analytik.jar. Java muss installiert sein, um es starten zu können. Anschließend kann man die jar-Datei mit folgender Anweisung zum Leben in der Konsole (cmd shell) erwecken: java -jar analytik.jar

Zuerst aktiviert man das Panel durch Anklicken der entsprechenden Checkbox. Es zeigt die Bestandteile des Rechners, wie den Speicher, den Kartenleser und das Rechenwerk. Mit der Schaltfläche Load wird das angegebene Programm geladen, mit der Schaltfläche Start wird es gestartet. Das Programm für den »Dampfrechner« lässt sich aus dem Internet laden: http:// www.fourmilab.ch/babbage/Examples/ex6.ae. Es liegt aber auch auf der DVD und kann als lokale Datei in der Load-Zeile angegeben werden. Das Programm ist gut kommentiert und kann neben der Anleitung dazu dienen, selbst Programme zu

83

2.4

2


entwerfen. Ein eigenes Programm zu schreiben ist jedoch nicht einfach und erinnert etwas an Assembler-Programme. Die Maschine ist nicht ganz so einfach zu verstehen, und eine ausführliche Erklärung würde den Rahmen dieses Buches sprengen. Es gibt jedoch ausführliche Dokumentationen im Internet: http:// www.fourmilab.ch/babbage/cards.html.

Abbildung 2.32

Simulation der Analytical Engine von John Walker

Auch die Anleitung direkt zum Applet findet man im Internet: http://www.fourmilab.ch/babbage/applet.html. Es gibt außerdem die Möglichkeit des Direktstarts des Applets von der Seite: http://ed-thelen.org/bab/bab-diff-JavaScript.html. Damit nicht genug. Auch wenn Babbages Maschine zu seinen Lebzeiten nie fertig wurde, heute läuft sie. Verschiedene Museen haben sie nachgebaut, aber auch begabte Bastler und Computerfanatiker – sogar mit Legobausteinen: http://acarol.woz.org/.

84


Quelle: www.chronarion.org/ada/AnalyticalEngine.jpg

Ein anderes Modell ist das von Tim Robinson. Was er realisiert hat, kann man sich auf seiner Webseite anschauen und anhören: http://meccano.us/difference_ engines/rde_2/index.html. Unter anderem gibt es dort auch die Difference Engine in Aktion zu bewundern. Wer sich die Filme nicht von der Webseite laden will, findet sie auch auf der DVD: Software zum Buch\Kap02\DifferenceEngine.

Abbildung 2.33

2.4.2

Analytische Maschine – Modell nach Babbages Entwürfen

Analoge Computer

All diese Rechenmaschinen sind digitale mechanische Rechner. Gleichzeitig gab es immer auch analoge Rechner, die Ergebnisse auf Skalen anzeigten, auch wenn sie wesentlich seltener vorkamen. Man hatte eben früh die Vorteile der diskreten Anzeige konkreter Ergebnisse erkannt. Analoge Geräte waren eher mit einer Uhr und dem Rechenschieber verwandt als mit diesen Maschinen, die Ziffern anzeigten. Sie arbeiten also nicht mit diskreten Elementen, die voneinander getrennte Werte darstellen, sondern mit Werten die ineinander übergehen. Das hat Vorteile, weil sie beliebige Zwischenwerte anzeigen können, aber auch gravierende Nachteile. Analoge Computer waren später, kurz vor dem Siegeszug der EDV, in bestimmten Bereichen wie der Simulation recht weit verbreitet. Man verglich einfach

85

2.4


Vorgänge, die zu untersuchen waren, mit simultanen Vorgängen im Analogrechner und zog daraus seine Schlüsse. Entsprechend ihrem anlogen Aufbau besitzen sie statt der Tasten viele Drehknöpfe.

© technikum29

2

Abbildung 2.34

Analogrechner

Abbildung 2.34 zeigt einen Analogrechner der Firma Heathkit. Die Firma, die ihr Geld mit Bausatzgeräten verdient, entwickelte diesen Analogrechner 1956 zu Ausbildungszwecken. Er war ein Ungetüm mit 70 Röhren, von denen 45 aus Kühlgründen außerhalb angebracht werden mussten. Die beachtliche Rechenleistung realisierte das Gerät über 15 Rechenverstärker. Nicht zuletzt gab es auch noch Rechenmaschinen, die digital und analog gleichzeitig arbeiteten, sogenannte Hybridrechner. Darin wurden die analog ermittelten Daten über digitale Schaltkreise weiterverarbeitet. So konnte man die Vorteile beider »Welten« in einer Rechenanlage nutzen. Der EAI 180 in Abbildung 2.35 stammt von Electronic Associates Incorporated, New Jersey, und aus dem Jahr 1970. Dieses Gerät ist mit DTL- Bausteinen, den integrierten Bausteinen der ersten Generation, ausgestattet. Wie beim ENIAC wird die Berechnung auf dem Frontpanel per Kabel zusammengesteckt. Jetzt haben wir die Rechner der vorelektronischen Ära – die Zeit der Rechner vor dem eigentlichen Computer – eingehend betrachtet. Im nächsten Kapitel geht es um die Entstehung des eigentlichen Computers.

86

© technikum29

Noch mehr Spaß: Sonnenfinsternis simulieren

Abbildung 2.35

2.5

Hybridrechner


Eindrucksvoller als Mondfinsternisse sind Sonnenfinsternisse, aber wie alle großen Ereignisse sind diese auch viel, viel seltener.

2.5.1

Eine deutsche Sonnenfinsternis

Es war am 11. August 1999, der Milleniumsbug machte bereits von sich reden, und der Vorbereitungsstress für den 31.12. plagte mich daher im Dienst schon ein paar Monate. Trotzdem hatte ich den festen Entschluss gefasst, mit meiner ganzen Familie an einem astronomischen Ereignis der Superlative teilzunehmen. Am Dienstagabend hatte ich die Vorhersagen der Wetterfrösche von vorn nach hinten und von hinten nach vorn studiert. Es war eindeutig, und ich meinte zu meiner Frau: »Das können wir vergessen, es wird regnen. Aber ich hab da eine Idee. Die Sonnenschein-Wahrscheinlichkeit bei Schlechtwetterlagen ist in »Außen« recht gut. Wir fahren zu meinen Eltern. Wenn die Sonne wegbleibt, wird’s ein Besuchstag.« Meine Frau und die Kinder waren einverstanden. Wie erwartet gab es tiefhängende Wolken, und der Regen begann auch schon bald. Gegen Westen wurde es etwas heller. Als wir nach Lebach kamen, wurde

87

2.5

2


natürlich haltgemacht: Zwischenstopp für das beste Speiseeis der westlichen Hemisphäre. An der Eistheke drehten wir uns um und sahen im Osten einen blauen Fleck am Himmel. Was mich dazu verleitete zu orakeln: »Du wirst sehen, wir werden in Schmelz wolkenfreien Himmel haben.« So war es. Als der Mond die Sonnescheibe rechts oben ankratzte, war der Himmel nur noch blau und blieb es, bis der Mond sich wieder davonmachte. Ringsumher das übliche Dorfleben, das sich von nichts aus der banalen Alltäglichkeit reißen ließ. Niemand blickte auf, während wir in Wassertonnen und mit zwei CD-Scheiben alles im Blick hatten. Ich konnte meine Mutter überzeugen, mit uns hinauszukommen. Wobei ich an die Finsternis 1966 dachte, bei der wir zwei auf einer Wallfahrt nach Marpingen im Wald von Abertausenden Sonnensicheln umflutet worden waren. Schließlich raste der Kernschatten heran, und mit der abreißenden Konvektionsströmung kam der Wind. Synchron dazu wurde der Sonnenwind der Korona am Firmament sichtbar. Sterne tauchten aus dem dunklen Blau des Himmels auf. Gegenüber, in einer Seitenstraße, hatte sich ein Tanklaster verfahren, der nun wieder rückwärts herausmanövrierte. Für ein paar Sekunden wurden wir eins mit dem gewaltigen Kosmos ... Aber langsam lief der Zauber wieder davon. Auf der Heimreise standen wir auf der nassen Landstraße im gleichen Stau mit denen, die aus dem verregneten Saarbrücken kamen. Stau zwischen Bauernhöfen – etwas, was wir wahrscheinlich so rasch nicht mehr erleben werden. Die meisten Menschen haben wohl ähnliche Erinnerungen an diesen Tag: »Die – vom ADAC bereits am 29.07.99 prognostizierten [8] – Staus am 11.08.1999 sind zur Legende geworden, genauso wie das Wetter an jenem Tag. Zumindest in England, Frankreich und Deutschland sah kaum jemand die Schwarze Sonne. Man brauchte schon Glück, um eines der wenigen Wolkenlöcher zu erwischen, wie z. B. in der Karlsruher Innenstadt [9]. Im Zentrum der selbsternannten ›SoFi-Hauptstadt‹ Stuttgart öffnete Petrus pünktlich zur totalen Phase alle Schleusen [10]. ARD und ZDF, deren LiveSendungen zur SoFi Quotenhits wurden (obwohl es durchaus einige Kritik an den Inhalten gab), waren auf Nummer sicher gegangen und hatten ein Flugzeug gechartert. Auf der sicheren Seite waren auch diejenigen, die sich bereits am Abend des 10.08.99 in ihren PKW gesetzt hatten und es bis in den Osten Österreichs oder sogar nach Ungarn schafften: Dort war das Wetter nämlich einwandfrei.

88


Wer unter Wolken stand, konnte zwar nicht die Schwarze Sonne sehen, kam aber gleichwohl in den Genuss eines ebenso eindrucksvollen wie beklemmenden Naturschauspiels: Fast schlagartig brach die Dunkelheit über die im strömenden Regen ausharrenden Menschen herein und verbreitete ein Gefühl völliger Hilflosigkeit, fast eine Weltuntergangsstimmung [11].« – http://www.sonnenfinsternis.org/sofi1999t/index.htm Wenn Sie, ohne eine weite Reise unternehmen zu müssen, ein solches Schauspiel erleben möchten, werden Sie auf die nächste totale Sonnenfinsternis (3. September 2081) in unserem Land warten müssen und auf gutes Wetter. Keine Lust? Versuchen Sie es mal mit dem 11.8.1999 und mit Stellarium. Diesmal können Sie auch das Standardformat für das Datum nutzen, denn es liegt nicht vor Christi Geburt. core.setDate ("1999-08-11T10:27:35")

Die dezimalen Koordinaten sind: Nord: 49.416667°, Ost: 6.833333° Woraus wir folgende Zeile machen: core.setObserverLocation(6.833333, 49.416667, 430, 1, "SchmelzAußen (Saar), Germany", "Earth");

Nun geht es nur noch darum, die Sonne als Ziel auszuwählen: core.selectObjectByName("Sun", false); StelMovementMgr.setFlagTracking(true);

Jetzt sollten wir vielleicht etwas näher an das Geschehen heranrücken: StelMovementMgr.zoomTo(5, 20);

Schließlich können wir es noch beschleunigen: core.setTimeRate(100); // 100 Sekunden in einer Sekunde erleben

Das fertige Programm befindet sich auf der DVD unter: Software zum Buch\ Kap02\Noch mehr Spaß\solar_eclipse_Schmelz.ssc.

2.5.2

Das erste Datum der Weltgeschichte

Nun sollte es nicht mehr allzu schwierig sein, mit Stellarium das erste genaue Datum der Weltgeschichte zu überprüfen. Nichts anderes ist die Sonnenfinsternis während der Schlacht am Halys, einem Fluss in der heutigen Türkei. Dieses erste genaue Datum der Weltgeschichte entbehrt nicht einer gewissen Brisanz, war es doch lange umstritten und ist bis heute nicht ganz geklärt.

89

2.5

2


Lesen wir das Original in deutscher Übersetzung: Herodot 1, 74: »Nach diesem, als Alyattes die Scythen auf die Ausforderung des Cyaxares nicht auslieferte, gab es Krieg zwischen den Lydiern und den Mediern auf fünf Jahre, in denen oft die Lydier von den Mediern, oft auch die Medier von den Lydiern besiegt wurden. Und einst kam es auch zu einer nächtlichen Schlacht. Indem sie nämlich den Krieg auf beiden Seiten gleich fortführten, trug es sich bei einem Treffen im sechsten Jahre zu, daß mit dem Ausbruch der Schlacht der Tag plötzlich zur Nacht ward. Diese Umwandlung des Tages hat auch Thales von Milet den Ioniern vorausgesagt, mit Vorherbestimmung dieses nämlichen Jahres, in welchem die Veränderung wirklich erfolgte. Als nun die Lydier und Medier die Nacht an die Stelle des Tages treten sahen, gaben sie nicht nur die Schlacht auf, sondern trieben um so mehr von beiden Seiten zu einem Friedensschluß.« – Quelle: Herodot's von Halikarnass Geschichte. Adolf Schöll. Verlag J. B. Metzler. 1829 Das ist der Ausgangpunkt. Nun stellt sich die Frage, war die Finsternis wirklich total und die Tageszeit sinnvoll für den Beginn einer Schlacht? Beides lässt sich mit Stellarium sehr leicht überprüfen. Die Vorhersage wurde bereits im Altertum viel beachtet und von zahlreichen Autoren wie Cicero erwähnt. Aber die genaue Datierung ist heute noch umstritten: »Herodot, Thukydides und Diogenes Laertius berichten davon, dass Thales von Milet die von Milet aus sichtbare Sonnenfinsternis vom 28. Mai 585 v. Chr. ›vorausgesagt‹ hat, und zwar in Form einer öffentlichen Ankündigung. Nach neueren Forschungen dürfte dies falsch sein. Er hat vielmehr die nur wenige Jahre später stattfindende, einem anderen Saros-Zyklus angehörende Sonnenfinsternis vom 16. März 581 v. Chr. angekündigt. Wahrscheinlich ist, dass er nur einen ungefähren Zeitpunkt angab, etwa in der Formulierung, sie werde ›vor dem nächsten pan-ionischen Fest‹ stattfinden. Die Wissenschaftshistoriker sind sich bis heute uneins, ob bzw. wie Thales zu solchen Berechnungen damals schon in der Lage gewesen sein soll. Plausibel ist folgende von Dmitri Panchenko (Akademie der Wissenschaften, St. Petersburg) in einem Aufsatz im ›Journal of the History of Astronomy‹ veröffentlichte Überlegung: Thales sei wahrscheinlich am Hof des Pharaos Necho (610–595 v. Chr.) assyrischen Astronomen begegnet, die angesichts der ständigen Attacken der Chaldäer und Meder auf ihr Königreich Assyrien an den ägyptischen Hof geflüchtet waren. Thales könnte über sie von den im 8. und 7. vorchristlichen Jahrhundert von chaldäischen Priestern aufgezeichneten Sonnenfinsternissen und deren 54-Jahre-Saros-Zyklen erfahren haben. Die Priesterastronomen

90


hatten noch keinen Begriff des Saros-Zyklus. Warum ein 54-Jahreskreislauf stattfand, war ihnen unbekannt. Aber sie hatten bereits ein Beobachtungswissen um das Faktum und hielten es über die Jahrhunderte in ihren Aufzeichnungen penibel fest. Thales jedenfalls wurde genau in diesem Jahr (585) wegen seines überragenden Geistes der erste Grieche, dem man den Rang eines ›Weisen‹ zubilligte.« – Quelle: http://www.geschichtsforum.de/f4/die-von-thales-v-milet-vorausgesagte-sonnenfinsternis-21405/ »Merkwürdigerweise entbehrt der historisch sehr interessante Bericht einer genauen Zeitbestimmung. Herodot berührt (allerdings in einem anderen Zusammenhang) diesen Krieg, und es hat den Anschein, als ob er ihn in dem ersten Teil der Kyaxareischen Regierung angesetzt haben wollte, aber bei näherer Betrachtung ersehen wir, dass es sich um eine bloße Parenthesis handelt, die für die Chronologie bedeutungslos ist. Demnach können wir aus Herodot nicht erfahren, ob der Kampf mit Alyattes vor oder nach dem Fall von Ninive entbrannt sei. Dagegen ist die Angabe der Sonnenfinsternis sehr wichtig, da nach dem uns erhaltenen Berichte eine totale, in den unteren Halysgegenden sichtbare Sonnenfinsternis gemeint ist, die bereits im Altertum den Gegenstand wissenschaftlicher Erörterungen abgegeben hat *. Die Neueren haben astronomische Berechnungen zwecks der Feststellung der Zeit dieser Sonnenfinsternis angestellt, und es hat sich ihnen der 30. September 610 v. Chr. als Tag der Thalesfinsternis ergeben. Dagegen machte Zech, Keplers und Newtons Berechnungen folgend, den Einwand geltend, dass diese Finsternis keine totale sein konnte, und hat sich für die Sonnenfinsternis vom 28. Mai 585 v. Chr. entschieden.« – Quelle: http://www.archive.org/stream/geschichtederme00prgoog/ geschichtederme00prgoog_djvu.txt Es könnte also durchaus sein, dass man noch nach einem anderen Datum forschen muss. Die NASA hat die Daten aller antiken Sonnenfinsternisse ins Netz gestellt. Wer Lust und Laune dazu hat, kann also die Geschichtsschreibung korrigieren oder es zumindest versuchen. Zusätzliche Hinweise 왘

Geschichte der Meder: http://de.wikipedia.org/wiki/Medien (Land)

왘

Historische Astronomie: http://www.spaceglobe.de/Produktinformation/Auszugl/Auszug2/Auszug3/auszug3.html

Wer sich die Beispiellösung ansehen möchte, findet sie hier: Software zum Buch\ Kap02\Noch mehr Spaß\solar_total-Halys.ssc.

91

2.5

2


2.5.3

Ring of Fire

Nein, es soll damit noch nicht genug sein. Sonnenfinsternisse gehören zu den eindrucksvollsten kosmischen Schauspielen, die uns unser Heimatplanet bieten kann. Aber nicht jede Sonnenfinsternis ist gleich. Eine dauert etwas über zwei Minuten, andere bis zu sieben Minuten. Das hängt jeweils davon ab, wo auf der Erde sie stattfindet und wie nah sich die beteiligten Himmelskörper gerade sind. Ist der Mond etwas weiter entfernt, während wir am sonnennächsten Punkt stehen, kann er die Sonnenscheibe gar nicht ganz bedecken, und es kommt zu einer der seltenen ringförmigen Sonnenfinsternisse. So geschehen am 15.1.2010 in Indien und China. Ein seltenes Schauspiel, das wir uns nicht entgehen lassen. Also das Datum ist: 15. Januar 2010, ab 7 Uhr 5, die Lokalität: Südindien, etwa in der Gegend um Madurai. Man benötigt unbedingt die richtigen Koordinaten. Google Maps tut sich damit etwas schwer. Es gibt jedoch andere Geo-Programme, die die Koordinaten anzeigen. Versuchen Sie es einmal damit: www.multimap.com. Geben Sie den Namen der Stadt ein (»Madurai«), und wählen Sie darunter als Land »India« aus. Über die find-Schaltfläche wird die Anzeige der Stadt aktiviert, unter der Karte stehen die Koordinaten. Lat: 9:53:01N (9.88363) Lon: 77:55:21E (77.92259) Das steht für Latitude (Breite) und Longitude (Länge). Bei core.setObserverLocation wird zuerst die Länge angegeben und dann die Breite, also: core.setObserverLocation(77.55, 9.88, 430, 2, "Madurai, India", "Earth");

Möchte man den Ring ganz exakt zentriert sehen, sollte man sich ein Schiff chartern und folgenden Punkt ansegeln: Lat: 6,41 Lon: 75,55 Google Maps (http://maps.google.de/) bietet übrigens die Möglichkeit, einen Ort anhand der Koordinaten anzusteuern. Hierzu gibt man im Adressfeld einfach »6.41, 75.55« ein. Ein funktionfähiges Skript finden Sie natürlich auf der DVD: Software zum Buch\ Kap02\Noch mehr Spaß\solar_eclipse_südindien_15_01_2010.ssc.

92

Lesen Sie weiter

2.6

Lesen Sie weiter

Quellen [1] »So überquerte er mit seinem Heer dann diesen reißenden Fluss, was allerdings mehrere Tage dauerte. Dies war kurz vor einer Mondfinsternis, die Alexander dazu veranlasste, Opfer für den Mond, die Sonne und der Erde darzubringen. Von dem maßgebenden Seher und Zeichendeuter Aristander von Telmessos wurde sie als gutes Vorzeichen für den Ausgang einer bevorstehenden Schlacht gedeutet. Kurz darauf wurde gemeldet, dass die Perser wenige Tagesmärsche weiter südlich, in der Ebene bei Gaugamela, zum Kampf bereitstanden.« http://www.alexanderdergrosse.de/schlacht bei-gaugatnela.php [2] »Aufgefangene Späher melden, dass Darius mit einem großen Heere am Tigris stehe, entschlossen, den Makedonen den Übergang zu wehren. Doch als Alexander an den Strom kommt, findet er weder von Darius, noch von den Persern überhaupt eine Spur und kann unbehindert seine Truppen übersetzen, infolge der reißenden Strömung des Tigris freilich mit weit größeren Schwierigkeiten, als beim Euphratübergang zu überwinden gewesen waren. Dem Heere wird einige Ruhe gegönnt. Für die genauere Zeitbestimmung hilft uns die Angabe einer Mondfinsternis (der Tag des Übergangs war der 20. September). Alexander opfert dem Monde, der Sonne und der Erde und erhält von Aristander, dem zeichenkundigen Seher, die erfreuliche Nachricht, noch in diesem Monat werde eine für die Makedonen günstige Schlacht geschlagen werden. – Der Marsch geht weiter zwischen dem Tigris zur Rechten und den gordyäischen Bergen zur Linken nach S. O. Am vierten Tage nach dem Tigrisübergange melden die Kundschafter, dass sich feindliche Reiter in der Ebene zeigen; wie sich bald herausstellt, sind es nur etwa 1000 Mann, ein von Darius ausgesandtes Beobachtungskorps. Alexander selbst an der Spitze der königlichen und einer zweiten Ile der Siaipo und der Päoner dem übrigen Heere vorauseilend, schlägt die Feinde in die Flucht und erfährt von Gefangenen, Darius mit seinem Heere sei nicht mehr weit. Deshalb macht er auf der Stelle des letzten Kampfes Halt und verwendet vier Tage darauf, ein mit Wall und Graben befestigtes Lager aufzuschlagen, wo er sein Gepäck und die Kampfunfähigen ...« *) Arrian III, 7, 6. Dieselbe Finsternis wird außer bei Alexanderhistorikern noch angeführt bei Ptolemaeos geogr. I, 4 und Plinius Nat. bist. II, 180. Die Datierung auf den 20/21. September gab richtig schon Scaliger (emend. temp. lib. 5). Genauere Angaben über die Dauer der Finsternis für Gaugamela s. b. Ginzel 93

2.6

2


»Spezieller Kanon der Sonnen- und Mondfinsternisse für das Ländergebiet der klassischen Altertumswissenschaften und den Zeitraum von 900 v. Chr. bis 600 n. Chr.« Berlin 1899. Vergl. auch Ideler, Handbuch der mathematischen und technischen Chronologie I, S. 347. » Die Schlacht bei Gaugamela: Eine Untersuchung zur Geschichte Alexanders d. Gr. und ihren Quellen; nebst einer Beilage..., Friedrich Hackmann, Verlag Buchdruckerei von H. John, 1902 *** Computer rechnen mit deinem Verständnis. – Wilma Eudenbach (*1959), deutsche Publizistin Webseiten zum Kapitel URL

Beschreibung

http://www.mechrech.info/workmod/ workmod.htm

funktionsfähige Modelle von Rechenmaschinen im Internet

http://www.henked.de/begriffe/ algorithmus.htm#Schickard

die Schickardmaschine im Internet

http://sprossenrad.iml-kirchlengern.de/ html/leibniz.html

die Leibnizsche Rechenmaschine

http://www.technikum29.de/de/

Technikum-Museumsseite

http://leifi.physik.uni-muenchen.de/ web_ph10_g8/umwelt_technik/ 07kausalitaet/versuche/doppelpendel/ Doppelpendel.html

Pendelsimulation

http://www.gwdg.de/fileadmin/ inhaltsbilder/Pdf/GWDG-Nachrichten/ gn0907.pdf

der Leibniz-Rechner

http://www.curta.de

Curta-Rechenmaschinen

http://www.curta.de/kr34/index.htm

Anleitungen für die Curta

http://www.curta.de/kr34/ curta_simulator_en.htm

Curta-Simulator von Jan Meyer

http://www.rechnerlexikon.de/

Homepage mit vielen mechanischen Rechnern

http://de.wikipedia.org/wiki/ Napiersche_Rechenst%C3 %A4bchen

Napierrechenstäbe bei Wikipedia

http://www.fourmilab.ch/babbage/

Seiten zu Babbage

94

Lesen Sie weiter

URL

Beschreibung

http://www.fourmilab.ch/babbage/ applet.html

Beschreibung zum Analytical Engine Applet

http://ed-thelen.org/bab/bab-intro.html

umfangreiche Infos zu Babbages Computer

http://ed-thelen.org/bab/ bab-diff-JavaScript.html

Online-Simulation der Analytical Maschine

http://meccano.us/difference_engines/ rde_2/index.html

Nachbau der Difference Engine

http://socserv2.socsci.mcmaster.ca/~econ/ ugcm/3ll3/babbage/index.html

Babbages Buch über die Automatisierung

Literatur zum Kapitel Kim, Eugene Eric und Toole, Betty Alexandra: Ada und der erste Computer. Spectrum der Wissenschaft 7/1999 S. 80. http://www.spektrum.de/artikel/825569& z=798888

95

2.6

Konrad Zuse baute 1938 den ersten Computer. Das Erstaunliche daran war, dass er nicht nur die Ideen dazu allein entwickelt hatte, sondern dass seine Konzepte in vielerlei Hinsicht so richtungsweisend waren, dass bis heute alle üblichen Computer nach diesen Prinzipien arbeiten. Und neben dem Computer hat er auch noch die erste echte Programmiersprache entworfen.

3

Vom ersten Computer und anderen Rechnersauriern

1823

1937

Babbage

Z1

1941

1943 1945 1946

1964

Z4 Atanasoff-Berry Collossus ENIAC IBM/360

3.1

Z wie Zuse

Der Krieg war so gut wie verloren, und längst galt die Direktive »Rette sich, wer kann!«, auch wenn es niemand laut aussprach. Der Bauingenieur Konrad Zuse hatte ein kaum zu bewältigendes Problem: Er besaß einen Rechner, einen Computer, der relativ fehlerfrei komplexe Berechnungen durchführen konnte, nur dass dieser so groß war, dass man ihn nirgends verstecken, kaum transportieren konnte. Vor allen Dingen nicht in diesen Tagen, wo nur Kriegswichtiges transportiert werden durfte. Die Lösung konnte nur sein, den Zuse 3 einfach kriegs-

97


wichtig zu machen – auch wenn er in Wahrheit mit dem Zweiten Weltkrieg wenig zu tun hatte.

© Computergeek; http://de.wikipedia.org

3

Abbildung 3.1

Zuse Z1 – Nachbau im Deutschen Technikmuseum Berlin

Doch lassen wir den Ingenieur und Erfinder selbst zu Wort kommen: »Der Mann erwies sich auch für uns als unbezahlbar. Als Physiker hat er nie für mich gearbeitet, aber er organisierte noch in den letzten Kriegswochen die Verlegung meiner Firma aus Berlin. Die meisten Versuchsgeräte waren zwar durch den Bombenkrieg zerstört oder beschädigt, aber die Z4 stand kurz vor der Vollendung. Sie hieß damals noch nicht Z4, sondern V4, was nicht mehr war als die Abkürzung für Versuchsmodell 4. Der Gleichklang dieser Abkürzung mit der für die sogenannten Vergeltungswaffen V1 und V2 hat unseren Computer gerettet. ›Die V4 muss aus Berlin in Sicherheit gebracht werden!‹, lautete die Parole. Sie stammte, natürlich, von Dr. Funk. Er organisierte den Transport zu einer Zeit, als selbst für Teile von Düsenjägern kein Waggon mehr aus Berlin herauszubekommen war.« [1] Seite: 81 Die V4, respektive die Z4, landete vom Bombenhagel weiterhin unbeschädigt letztendlich in einer Scheune in Hinterstein, im Allgäu. Es handelte sich dabei immerhin bereits um das vierte Modell eines funktionsfähigen Computers und keineswegs um irgendein nur halb funktionsfähiges Anschauungsmodell, was sich nach dem Krieg recht schnell herausstellen sollte. Schließlich wurde die Z4 von der Uni Zürich angemietet, zum Kauf fehlte das Geld. Dort leistete sie ganze

98

Z wie Zuse

fünf Jahre treue Dienste und ging danach noch an ein deutsch-französisches Forschungsinstitut. Zuse erzählt darüber:

© Clemens PFEIFFER; http://de.wikipedia.org

»Eines Tages – es war im Jahr 1949 – tauchte ein vornehmer Wagen aus der Schweiz in Hinterstein auf. Professor Stiefel von der Eidgenössischen Technischen Hochschule Zürich war zu Ohren gekommen, dass irgendwo in einem kleinen Dorf im Allgäu ein Computer zu finden sei. Er war eben von einer Studienreise in die USA zurückgekommen, wo er »viel schöne Maschinen in schöne Schränk mit Chromleisten« gesehen hatte. Der Professor war nicht wenig überrascht, als er die äußerlich doch schon ein wenig ramponierte Z4 auch noch in einem Pferdestall aufgebaut fand. Trotzdem diktierte er mir eine einfache Differenzialgleichung, die ich sofort programmieren, auf der Maschine vorführen und lösen konnte. Danach schlossen wir einen Vertrag: Die Z4 sollte – nach gründlicher Überholung und Reinigung – an die ETH ausgeliehen werden.« [1] Seite: 105

Abbildung 3.2

Die Original-Zuse Z4 im Deutschen Museum in München

Zum Glück war die Z4 im Krieg nicht zu Schaden gekommen, sie diente Zuse als Grundlage für den Aufbau seiner neuen Firma, der Zuse KG. Sie wurde von ihm zusammen mit Harro Stucken und Alfred Eckhard 1949 in Neukirchen, Kreis Hünfeld, gegründet. Bereits 1964 wurde sie von der BBC übernommen, die sie 1967 zu 70 % an die Siemens AG verkaufte. Diese übernahm sie schließlich ganz und ließ 1971 den Namen Zuse KG löschen. Bis zu ihrer Auflösung hatte die

99

3.1

3


Firma 251 Rechner gebaut. Die ersten Rechner bestanden wie die Z4 noch aus Relais, die rasch von Röhren ersetzt wurden. Schließlich wurden die Rechner mit Transistoren bestückt. Als die ersten ICs aufkamen, gab es die Zuse KG bereits nicht mehr. Aber sie hatte immerhin drei Rechnergenerationen innovativ mitgestaltet. Auch auf dem Gebiet der Rechner-Peripherie hatte man federführend Neuentwicklungen geschaffen, wie den Zeichentisch Z64, den Vorläufer der heutigen Plotter. Diese Erfolgsgeschichte ist umso erstaunlicher, als Konrad Zuse nicht etwa ein begnadeter Mathematiker war, wie Leibniz oder Blaise Pascal, sondern Bauingenieur und zunächst einmal nur ein vielseitig begabter junger Mann mit regem Interesse an allem, was es zu erfinden und zu verbessern galt. Zeichnerisch war er hochbegabt, versuchte sich aber auch als Bühnenbildner, Schauspieler, Städteplaner, Dichter und Autor. Am liebsten schraubte er kleine technische Wunderwerke mit Hilfe eines Technikbaukastens zusammen, so beispielsweise einen Warenautomaten mit Geldrückgabe. Schon früh hatte er die Idee, auch so theoretische Arbeiten wie das Rechnen mit einem mechanischen Gerät zu unterstützen. Nach seinem Studium wurde er Statiker bei den Henschel Flugzeugwerken, gab die Stelle jedoch auf, um als freier Erfinder zu arbeiten. In der Wohnstube seiner Eltern begann er damit, einen mechanischen Computer zu bauen. Als Rechenelemente verwendete er – da er sich von Anfang an für die binäre Arithmetik entschieden hatte – Blechstreifen, die zwei Positionen einnehmen konnten. Im Internet kann man sich Animationen anschauen, die zeigen, wie Konrad Zuse diese Schaltelemente realisierte: 왘

http://www.zib.de/zuse/Inhalt/Programme/Simulationen/Z1/Z1Sim/ simple.html

왘

http://www.zib.de/zuse/Inhalt/Programme/Simulationen/Z1/Z1Sim/ variant.html

Konrad Zuse wusste damals nichts von den beiden Computern Babbages, er sollte erst auf dem amerikanischen Patentamt erfahren, dass 100 Jahre zuvor der englische Mathematiker bereits konkrete Entwürfe zu einem mechanischen Computer ausgearbeitet hatte. Es gab allerdings große Unterschiede: Babbages Rechner sollte dezimal arbeiten, und Zuses Rechner arbeitete binär. Es galt eine ganze Reihe von Problemen zu lösen, doch die gewonnenen Erfahrungen beim Bau dieses Z1 getauften Rechners versetzten Zuse in die Lage, weitere Modelle zu entwickeln. Man hatte bereits erste Ideen zu Röhrenrechnern, doch der zweite Rechner sollte ein Relaisrechner werden. Es wurden umgebaute Telefonrelais genutzt, weil diese leicht und in ausreichender Menge beschafft

100

Z wie Zuse

© Axel Mauruszat; http://de.wikipedia.org

werden konnten. Während der Z1 aufgrund seiner Mechanik nicht sehr zuverlässig arbeitete – die Schaltbleche verhakten sich öfters –, gab es beim Z2 Probleme mit den Relais. Trotzdem zeigte sich, dass sie um vieles besser waren als die rein mechanische Konstruktion. So wurde die 1941 gebaute Z3 ein reiner Relaisrechner. Nach ihrer Fertigstellung wurde sie einer Gruppe von Wissenschaftlern vorgestellt. Der Wunsch, ein Nachfolgemodell in Röhrentechnik zu bauen, fand jedoch keine Unterstützung. Die Z3, der erste voll funktionsfähige und binär arbeitende Computer der Welt, wurde am 21. Dezember 1943 bei einem Bombenangriff zerstört. In Berlin ist heute an der Stelle, an der Zuse damals diese Rechner entwickelte, eine Gedenktafel angebracht.

Abbildung 3.3

Zuse-Gedenktafel in Berlin

Da Konrad Zuse keine Röhren zur Verfügung standen, baute er seine Z4 aus 2.200 Relais. Heute steht dieser Rechner, der – wie bereits erwähnt – erst an die ETH Zürich verliehen und später an einen französischen Rüstungskonzern verkauft wurde, im Deutschen Museum in München. Konrad Zuse war natürlich nicht der Einzige, der damals daran dachte, einen Computer zu bauen. Sowohl in Amerika als auch in England wurde an Rechenautomaten gearbeitet (siehe Tabelle 3.1). In Amerika entstanden 1941 der Atanasoff-Berry-Rechner, der binär arbeitete, jedoch nicht frei programmierbar war, und 1944 der Mark I sowie der ENIAC. In England wurden 1943 der Colossus und 1949 der EDSAC gebaut.

101

3.1


© Magnus Manske; http://de.wikipedia.org

3

Abbildung 3.4

Zuse Z3-Nachbau im Deutschen Museum in München

Auch ohne dass zwischen den Entwicklern der ersten Computer Kontakt bestanden hatte, entwickelten sie im Grunde alle die gleiche Idee und dieselben Maschinen. Die Zeit war einfach reif geworden für die universelle Maschine Computer. Der Zweite Weltkrieg war keineswegs der direkte Auslöser für diese Entwicklungen, sondern nur eine Art Katalysator, ein Beschleuniger. Name

Technik

Baujahr

Zahlsystem

Programmierung

Zuse Z1

Schaltbleche

1937

binär

über Filmstreifen

Zuse Z2

Relais und Bleche

1939

binär

über Filmstreifen

Zuse Z3

Relais

1941

binär

über Filmstreifen

Atanasoff-Berry Röhren

1937–1941

binär

nur begrenzt

Colossus

Röhren

1943

nicht binär

nur begrenzt

Mark I

Relais

1944

dezimal

über Lochstreifen

ENIAC

Röhren

1944

dezimal

per Steckkabel

Manchester Mark I

Röhren

ab 1945

binär

per Eingabe

Tabelle 3.1

102

Die ersten Computer

Z wie Zuse

Praxis: Rechnen mit dem Z3 Die ersten Rechner von Konrad Zuse gingen im Krieg leider verloren. Nachbauten der Rechner Z1 und Z3 existieren inzwischen wieder in deutschen Museen. Dort kann man, wenn man Glück hat, bei einer Vorführung zusehen, wie sie rechnen. Sie selbst bedienen darf man in der Regel nicht. Zum Glück gibt es inzwischen bezahlbare Exemplare von Zuses Erfindung in fast jedem Haushalt, und mit diesen Computern kann man andere Computer simulieren. Im Internet findet man sehr schöne Simulationen von Zuse-Rechnern. Selbst Animationen zu Schaltelementen aus Blechstreifen vom Z1 sind vorhanden. Die Simulation des Z3 als Java-Applet findet man unter http://www.zib.de/zuse/ Inhalt/Programme/Simulationen/Z3_Sim/index.html Klicken Sie links die Schaltfläche Start an, und rufen Sie über die Schaltfläche Starte Simulation das Applet auf. Damit das funktioniert, muss der Browser Java unterstützen, es muss also installiert sein. Eine Dialogbox wie in Abbildung 3.5 öffnet sich.

Abbildung 3.5

Zuse Z3-Simulation als Applet von Alexander Thurm

103

3.1

3


Bei dem Programm sieht man links die Eingabetastatur und die Ausgabe, wobei zu beachten ist, dass die Eingabetasten über der Anzeige angeordnet sind. Das obere Zahlenfeld neben dem Filmstreifen ist die Tastatur. Rechts daneben ist die Recheneinheit mit zwei ALUs1 schematisch dargestellt. Darüber liegt der Filmstreifen, um Programme zu speichern und einzulesen. Rechts befinden sich die Bedienungsschalter. Die Z3 arbeitete mit umgekehrter polnischer Notation – also erst beide Operanden und anschließend die Operation. Man stellt z. B. auf der Tastatur 100 ein und klickt auf Einlesen. Unten links auf der Anzeige sieht man, dass R1 aktiviert ist. R1 steht für Register12. Jetzt stellt man die nächste Zahl ein, beispielsweise 22. Wieder ist Einlesen anzuklicken. Nun wird die Operation durch Klicken auf Addition eingestellt. Danach braucht man nur noch durch Anklicken von Ausgeben das Ergebnis anzeigen zu lassen. Unterhalb der Tastatur wird 122 angezeigt (siehe Abbildung 3.5). Zu beachten ist die Position des Kommas, das bei dem Originalrechner nur als eine negative oder positive Zahl angegeben wurde. Bei diesem Beispiel gibt es zwei Nachkommastellen. Das Komma bei der Eingabe kann mit dem Rad links neben den Eingabetasten eingestellt werden. Um den Rechenvorgang an der schematischen Darstellung verfolgen zu können, schalten Sie über die Menüzeile Optionen 폷 Verfolgung an. Wählen Sie Programm 폷 neu, werden zusätzliche Schalter sichtbar, mit denen man ein Programm aufzeichnen und wieder laden kann. Auf der DVD ist eine weitere Simulation enthalten: Software zum Buch\Kap03\ Z3-vrml\simulation.html. Es handelt sich hierbei um eine wunderschöne VRMLSimulation von Alexander Knabner, wobei VRML für Virtual Reality Markup Language steht. Es ist also eine Sprache, um virtuelle Räume zu beschreiben. Wie die Dateiendung html zeigt, kann die Datei mit einem Browser geöffnet werden. Damit ein Browser jedoch 3D-Szenen darstellen kann, benötigt er ein spezielles VRML-Plugin. Ein Plugin finden Sie auf der DVD unter Software zum Buch\ Kap03\WRL-Plugin\cortona3d.msi. Leider funktioniert das Plugin nicht mit jedem Browser und jedem System. Deshalb bezieht sich die folgende Beschreibung auf einen Standalone Viewer, der ebenfalls auf der DVD enthalten ist. Allerdings ist es eine Demoversion, die ein Emblem auf der Sicht laufen lässt, was jedoch bei dem, was wir damit sehen wollen, nicht stört (Software zum Buch\Kap03\WRL-Plugin\BS_Contact_VRMLX3D_7106.exe). 1 ALU, die Abkürzung für arithmetisch logische Einheit, ist der sogenannte Prozessorkern. Er wird mit einem V symbolisch dargestellt. Zwei Werte werden oben eingelesen und verknüpft, und am Fuß wird das Ergebnis ausgegeben. 2 Zwischenspeicher 1.

104

Z wie Zuse

Nach der Installation des Programms wird BS Contact über das Startmenü aufgerufen. Ein Dialogfenster mit dem Titel Bitmanagement Software GmbH öffnet sich. Über File 폷 Open... 폷 Browse wird die Datei z3model.wrl aufgerufen, die im Verzeichnis Software zum Buch\Kap03\Z3-vrml\vrml liegt. Ein Blick auf die Z3 wird geladen (siehe Abbildung 3.6).

Abbildung 3.6

Zuse Z3 als 3D-VRML-Simulation

Klickt man mit der rechten Maustaste in das Bild, erhält man ein Kontextmenü mit dem Menüpunkt Standorte. Über diesen Punkt kann man für die Bedienung an die Konsole treten (Edit) und sich das Ergebnis ansehen (Output). Die Simulation funktioniert genau wie das Java-Applet, nur dass hier das Einlesen die Taste über den nach rechts unten weisenden Pfeil geschieht (Ì) und die Ausgabe über den nach rechts oben weisenden Pfeil Ê). Eine Rechnung sieht also folgendermaßen aus: 0100 Ê 0022 Ê + Ì Abbildung 3.7 zeigt das Ergebnis.

105

3.1

3


Abbildung 3.7

Konsole des Z3 mit Additionsergebnis 122,00

Die Stellung des Kommas wird hier richtig mit der –2 im Anzeigefeld dargestellt. Innerhalb der VRML-Simulation kann man sich nicht nur durch die Auswahl des Standorts bewegen, sondern auch mit der Maus und dem Mausrad. Bei gedrückter linker Maustaste kann man drehen und sich vor- und zurückbewegen, mit dem Mausrad kann man nach oben und unten kippen.

3.2

Die geheime Schlacht der Codeknacker

Das Bundeskanzleramt lehnte mit der Begründung ab, so ein Fernschreiber sei doch kein Kulturgut, für das der Kanzler bürgen müsse. Daher sah es fast danach aus, als würde das große Cipher Event im Rahmen der Ausstellung im Heinz Nixdorf Museum Paderborn am 16. November 2007 gar nicht stattfinden können. Glücklicherweise verzichtete man von englischer Seite auf amtliche Garantien und stellte den Fernschreiber unter Bewachung trotzdem zur Verfügung. Es handelte sich keineswegs um einen gewöhnlichen Fernschreiber, sondern um die sogenannte Schlüsselfernschreibmaschine SZ42 von Standard Elektrik Lorenz, die den Kommandostellen der Wehrmacht für streng geheime Nachrichten vorbehalten gewesen war. In einem Wettbewerb zur Inbetriebnahme des Colossus106


Nachbaus und zur Sonderausstellung »Tricksen, Täuschen und Tarnen« im Paderborner Computermuseum sollte ein original-chiffrierter und versandter Text entschlüsselt werden. Neben der Original-Elektrik-Lorenz kamen auch alte Funkgeräte zum Einsatz und als Höhepunkt des Ganzen natürlich der Nachbau des Colossus. Tony Sale, ein Ingenieur und ehemaliger technischer Mitarbeiter des Nachrichtendienstes MI5 baute den Colossus federführend für das Computermuseum in Bletchley Park ab 1990 nach.

Quelle: www.codesandciphers.org.uk/lorenz/rebuild.htm

Von den Original-Colossus-Maschinen erfuhr die Weltöffentlichkeit erst 1970. Colossus war so geheim, dass es weder Baupläne noch Bedienungsanleitungen für ihn gab. Es wurden zwar insgesamt zehn Exemplare dieses »Computers« gefertigt, aber alle Geräte mussten 1946 aus Geheimhaltungsgründen vollständig demontiert werden. Zumindest bei den englischen Anlagen ist dies auch geschehen. Ein amerikanisches Exemplar soll »überlebt« haben.

Abbildung 3.8

Colossus 2 – der Nachbau von 1990

Der ganze Wettstreit hatte mit einigen Pannen zu kämpfen. Nicht nur, dass die Bürgschaft abgelehnt wurde, bei einem Test der Chiffriermaschine kam es zu einem Kurzschluss, Sicherungen brannten durch, und weitere Bauteile wurden in Mitleidenschaft gezogen. Daher musste der Restaurator und Physiker Craig Sawjers aus dem Museum in Bletchley Park das Flugzeug besteigen und anreisen, um den Schaden zu beheben, was ihm zum Glück auch gelang.

107

3.2

3


Der Wettbewerb begann damit, dass am Donnerstag um 9 Uhr die verschlüsselte Nachricht mit den historischen Funkgeräten in den Äther geschickt wurde. Bereits am Freitag um 13 Uhr 14 hatte Colossus die Nachricht entschlüsselt. Sie begann mit den Worten: »FASZINIEREND_UND_SPANNEND:_DIE_WELT_DER_ZAHLEN_VON_ DER_GLUCKSZAHL_UBER_TELEFONNUMMERN_BIS_ZUR_ GEHALTSABRECHNUNG_WIRD_UNSER_ALLTAG_VON_ZAHLEN_ BESTIMMT._DASS_ZAHLEN_NICHT_LANGWEILIG_SEIN_MUSSEN,_ KANN_JEDER_IN_EINER_GROSSEN_AUSSTELLUNG_DES_HEINZ_ NIXDORF_MUSEUMSFORUMS_IN_PADERBORN_VOM_1._FEBRUAR_ BIS_18._MAI_2008_ERLEBEN_IM_'JAHR_DER_MATHEMATIK'_ PRASENTIERT_DAS_HNF_AUF_700_QUADRATMETERN_'ZAHLEN,_ BITTE'_DIE_WUNDERBARE_WELT_VON_NULL_BIS_UNENDLICH'...« Doch das Pech verfolgte die Veranstalter weiter, und beim Rechnerstart zerplatzte erst einmal eine der 2.400 Röhren mit lautem Knall. Der Rechner musste stillgelegt, die Röhre gewechselt und der Rechner wieder hochgefahren werden – was fast eine Stunde Zeitverlust mit sich brachte. Die Unglückssträhne gipfelte jedoch darin, dass ein anderer Teilnehmer längst am Ziel war. Also gewinnen konnte Colossus das Rennen ohnehin nicht mehr. Das hatte nämlich der 40-jährige Bonner Funkamateur Joachim Schüth schon für sich entschieden. Bereits am Donnerstagmittag konnte er den Klartext abliefern. Nur 46 Sekunden hatte sein für den Cipher Event geschriebenes Ada-Programm benötigt, um aus dem unverständlichen Buchstabensalat lesbaren Text zu machen. Natürlich hatte er keinen antiquarischen Röhrenrechner zur Verfügung, sondern seinen 1,4 GHz-Laptop dafür verwendet. Dabei war der Zeitpunkt der Veranstaltung wirklich gut gewählt. Am 15. November, einen Tag vor dem Start des Events, jährte sich die Geburt von Claus Philipp Maria Schenk Graf von Stauffenberg zum hundertsten Mal. Auch er hatte die Möglichkeiten der deutschen Verschlüsselungstechnik genutzt, und nach dem gescheiterten Attentat trat ein Sonderausschuss zusammen, um die Sicherheit der Verschlüsselung zu verbessern. Was dazu führte, dass der britische Geheimdienst in Bletchley Park plötzlich vor unlesbaren Nachrichten stand. Und das gerade in der Zeit kurz nach der Landung der Alliierten in der Normandie. Erst der Einsatz weiterer Colossus-Mark-II-Anlagen versetzte die Verschlüsselungsfachleute in die Lage, wieder hinter die deutschen Geheimnisse zu kommen. So wirkten sich die Colossus-Anlagen auf den Ausgang des Krieges entscheidend aus. Man schätzt, dass sich die Dauer des Zweiten Weltkriegs in Europa durch den Einsatz der Colossus-Anlagen wenigstens um vier Monate verkürzt hat.

108


Echte Computer waren es trotzdem nicht. Von seinen Möglichkeiten her war Colossus eine universelle Rechenmaschine nach den Konzepten von Turing. Der Mathematiker Max Newman hatte ihn entworfen. Aber da er nur für Entschlüsselungsaufgaben genutzt und nicht frei programmiert werden konnte, war er kein vollwertiger Computer. Der erste vollwertige Rechner auf Basis der Röhrenelektronik hieß ENIAC und wurde in Amerika gebaut. »Das Charakteristikum des Computers: Alle Informationen schwimmen mit dem Strom.« – Prof. Dr. Hans-Jürgen Quadbeck-Seeger (*1939), deutscher Chemiker An einem Mark II arbeitete damals auch Grace Brewster Murray Hopper, eine Frau, die erst 1986 im Alter von 80 Jahren in den Ruhestand gehen sollte. Man hatte sie nach der regulären Verrentung noch einmal bei der US Marine angefordert, damit sie half, diverse Computerprobleme zu beheben, Bugs, wie man unter Informatikern zu sagen pflegt. Damit kannte sie sich wohl gut aus, denn manche


behaupten, sie haben den ›Bug‹ erfunden.

Abbildung 3.9

Grace Brewster Murray Hopper

1947 war der Mark II ausgefallen, an dem sie arbeitete. Nach intensiver Suche fand man an einem Relais eine Motte, die einen Kurzschluss verursacht hatte. Frau Hopper klebte die Motte in ihre Berichtsmappe und schrieb dazu: »Der erste echte Bug, der gefunden wurde«.

109

3.2



3

Abbildung 3.10

Der erste Computerbug

Tatsächlich war der Begriff »Bug« für einen Fehler schon geläufig, nur verhalf sie ihm zu weiterer Popularität. Noch bekannter wurden Computerfehler (Bugs) durch den sogenannten Millenium-Bug, an dem sie auch indirekt beteiligt war. Die Probleme, die beim Jahrtausendwechsel auftraten, weil die Jahreszahlen im Datum in der Regel zweistellig gespeichert waren, hatten ihren Ursprung im zweistelligen Jahresdatum, das Frau Hopper bei der Entwicklung der Computersprache Cobol eingeführt hatte, um Speicherplatz zu sparen. Trotz all der Bugs erhielt sie in ihrem Leben mehr als 90 Auszeichnungen und 40 Ehrendoktortitel.

3.3

ENIAC – im Dienste der Armee

ENIAC steht für Electronic Numerical Integrator and Computer. In der Tat war er der erste rein elektronisch arbeitende Universalrechner. Die US-Armee gab ihn 1942 für 468.000 $ in Auftrag, um mit ihm Geschosstabellen errechnen zu lassen. Gebaut wurde er von J. Presper Eckert und John W. Mauchly an der University of Pennsylvania. Die Leistung dieses Computers entsprach gerade mal der eines heutigen programmierbaren Taschenrechners, obwohl der ganze Rechner nicht weniger als 27 Tonnen wog. Er bestand aus 40 Komponenten, die je nach Bedarf in Betrieb genommen wurden. Seine Entwickler hatten etwa 70.000 Widerstände, 1.500 Relais, 7.200 Dioden und 17.500 Röhren verbaut. Insbesondere die Röhren

110


machten sehr viel Kummer, weil aufgrund ihrer Lebensdauer praktisch alle zwei Minuten eine Röhre ausfiel. Man hatte extra eine Art Servicesoftware entwickelt, die defekte Röhren lokalisierte. Denn fiel eine Röhre aus, machte der ENIAC Rechenfehler. Durch stärkere Röhren konnte man das Problem mindern. Auch gingen die meisten Röhren beim Ein- und Ausschalten kaputt, weshalb man ihn schließlich rund um die Uhr durchlaufen ließ. Programmiert wurde er durch Steckbrücken, das heißt, man verband die gewünschten Funktionen mit Kabeln. Die Operation, die er ausführen sollte, konnte man per Drehschalter einstellen. Gerechnet wurde im Dezimalsystem. Das war mit einer der Gründe, warum der Rechner so aufwendig geworden war. Endgültig abgeschaltet wurde der ENIAC am 2. Oktober 1955. Zuvor war er noch nach dem John-von-Neumann-Konzept zu einem Rechner mit Befehlsspeicher umgebaut worden. Dadurch wurde er zunächst wesentlich langsamer, aber die langwierige Programmiertätigkeit durch Umstecken von Kabeln entfiel, so dass er insgesamt schneller war. Von Neumann, auf den die theoretischen Vorarbeiten für unsere moderne Rechnerarchitektur zurückgehen – die sogenannte Von-Neumann-Architektur, bei der das Programm mit den Daten im Hauptspeicher abgelegt wird –, hatte den ENIAC selbst noch für Berechnungen für die Atombombe genutzt. John von Neumann Johann Neumann war der Sohn eines jüdischen Bankiers aus Ungarn, dessen Familie durch Kauf eines Titels adlig wurde. Geboren wurde er am 28.12.1903 in Budapest (Österreich-Ungarn) und getauft auf den Namen Margittai János Lajos Neumann. Er war ein hochbegabtes Kind und besuchte in Budapest das deutschsprachige Gymnasium. Bereits mit 17 veröffentlichte er seinen ersten mathematischen Artikel. Er studierte zwar Chemie, interessierte sich aber in erster Linie für Mathematik. Nach dem Studium war er von 1926 bis 1929 der jüngste Privatdozent der Berliner Universität. Als Mathematiker arbeitete er zunächst bei Hilbert in Göttingen am Hilbertprogramm, der Vorstufe zur Principia Mathematica3. Als Gödels Unvollständigkeits-

3 Bertrand Russel wollte damit widerspruchsfrei die Mathematik aus der formalen Logik ableiten, was beweisen sollte, dass die Mathematik nicht an sich wahr ist, sondern auf den Gesetzen der menschlichen Kommunikation aufbaut. Die Existenz von widerspruchsfreien Gedankengebäuden wurde jedoch von Gödel ad absurdum geführt.

111

3.3

3


satz bekannt wurde, beendete er diese Forschungen und wandte sich der Quantenmechanik zu. Er gewann zahlreiche neue Erkenntnisse hinsichtlich der Quantenphysik und der Mathematik. So wird z. B. die Spieltheorie auf seine Arbeiten zurückgeführt. Beim amerikanischen Atombombenprojekt gehörte er zum Kreis derer, die festlegten, wo die Bomben auf Japan abgeworfen werden sollten. An den Weiterentwicklungen bis zur Wasserstoffbombe war er ebenfalls beteiligt. Das brachte ihm die zweifelhafte Ehre ein, Vorbild für Stanley Kubricks Film »Dr. Seltsam oder: Wie ich lernte, die Bombe zu lieben« gewesen zu sein. Er war ein nüchterner Wissenschaftler, ohne ethische Skrupel. Dabei war er immer ein Mensch, der gerne seine Ideen mit anderen teilte und wenig Wert darauf legte, als Urheber einer Idee bekannt zu werden. Außerordentliche Verdienste erwarb er sich auch durch seine Arbeiten zur Entwicklung von Computern. Jeder, der sich ernsthaft mit der Informatik auseinandersetzt, kennt den Begriff der Von-Neumann-Architektur. Das ist sozusagen der Bauplan aller modernen Rechner. Nach dieser Idee liegen Programme und zu bearbeitende Daten in einem modifizierbaren Speicher. Dadurch ist es möglich, im Programm ablaufabhängige Sprünge durchzuführen (sogenannte IF-THENGOTO-Programme). Die Von-Neumann-Architektur beruht auf den Bausteinen Steuereinheit, arithmetische Einheit und dem Speicher. Zwar hatte Konrad Zuse das Prinzip schon vorher für seine ersten Computer genutzt, aber die wissenschaftliche und mathematische Erforschung des Prinzips gelang erst von Neumann. Ab 1949 leitete er am Institute for Advanced Study ein eigenes Computerprojekt, den sogenannten IAS Computer. Hier realisierte er zahlreiche neue Ideen, darunter auch etliche Programmierkonzepte wie Listen, doppelt genaue Zahlen, Sortierfunktionen, aber auch Flussdiagramme. Verwendung fanden seine Computer wiederum im militärischen Bereich. Man sollte allerdings auch erwähnen, dass er mit diesem Rechner erstmalig numerische Wettervorhersagen durchführte, unter anderem die erste rechnergestützte 24-Stunden-Wetterprognose. Bereits 1953 entwickelte J. von Neumann die Theorie der selbstreproduzierenden Automaten. Aus ihr ging die Theorie der zellulären Automaten hervor, zu der auch John Conways Spiel Life gehört. Ebenfalls verbunden damit ist die Idee künstlichen Lebens. Science-Fiction-Autoren malten sich die Eroberung des Alls mit solchen Automaten aus, die sich selbst reproduzieren können, und erfanden dafür den Namen Von-Neumann-Sonden. John von Neumann starb am 8.2.1957 in Washington.

112


Praxis: Rechnen mit dem ENIAC Auch für den ENIAC gibt es Simulationen für den PC, die das abenteuerliche Gefühl vermitteln können, das Forscher, wie z. B. unser Dr. Seltsam, empfunden haben müssen, als sie den ersten elektronischen Computer der Welt programmierten. Die von den Ingenieuren entwickelten Programme wurden damals übrigens ausschließlich von Frauen eingestellt. Daher prägte man den Begriff der ENIAC-Frauen. Die ENIAC-Simulation, die nun besprochen wird, ist ein Java-Programm. Um sie zum Laufen zu bringen, sollte man die Java-Version nutzen, die sich auf der Buch-DVD befindet. Neuere Versionen laufen nicht. Wenn man sich seine aktuelle Rechner-Installation nicht kaputtmachen möchte, kann man einen virtuellen Rechner installieren. Die Java-Version finden Sie unter Software zum Buch\Anhang\Installationen\ Java jre-6u2-windows-i586-p-s.exe. Es genügt, dieses JRE zu installieren, das JDK ist nicht erforderlich. Die ENIAC-Simulation finden Sie im Netz unter http://www.zib.de/zuse/Inhalt/ Programme/eniac/index.html. Der Start gelingt über einen der beiden ersten Links: 왘

Click here to start the ENIAC simulation as Java Applet

왘

Click here to start the ENIAC simulation by Java Webstart

Webstart ist Teil des Java-JRE und erlaubt es, Java-Software über das Internet zu nutzen. Vor dem Start wird das entsprechende Programm erst auf der heimischen Festplatte zwischengespeichert. Applets dagegen werden in den Speicherbereich geladen, den der Browser nutzt, und laufen auch meist auf der Oberfläche des Browsers. Von daher wird der Start als Applet wahrscheinlich einfacher sein.

Um eine der beiden Möglichkeiten nutzen zu können, muss eine ältere Java-Version installiert sein. Für Internet-Puristen befindet sich die Simulation des ENIAC auch auf der BuchDVD: Software zum Buch\Kap03\ENIAC\eniac.jar (siehe Abbildung 3.11). Die Datei kann durch einen Doppelklick gestartet werden. Natürlich nur, wenn bereits eine JVM (Java Virtual Machine) auf dem Rechner installiert ist. Es sollte, wie bereits gesagt, eine ältere Version sein. Falls der Doppelklick versagt, versuchen Sie es in der Eingabeaufforderung mit: java -jar eniac.jar

113

3.3

3


Abbildung 3.11

Mitgelieferte ENIAC-Programme

Wie man auch startet, zunächst öffnet sich ein Dialog, mit dessen Hilfe eines der beiliegenden Programme für den ENIAC geladen werden kann. Die Programme befinden sich ebenfalls in dem gepackten Dateiarchiv (jar-Datei). Eigentlich sind es lediglich drei Programme und vier Grundkonfigurationen. Die Konfigurationen dienen dazu, selbst Programme auf dem Rechner einzurichten. Sie stellen unterschiedliche Hardwarekonfigurationen des Rechners dar. Die vorhandenen Programme sind folgende: Simple example Dieses Programm ist ein ganz einfacher Algorithmus, der 8 mit 5 multipliziert und schließlich 2 hinzuaddiert. Dieses Programm wird auch geladen, wenn man nichts auswählt, deshalb werden wir es uns als Erstes ansehen. Euklidscher Algorithmus Diese Rechenregel, die Euklid zugeschrieben wird, erlaubt das Finden eines größten gemeinsamen Teilers zweier natürlicher, nicht gleich großer Zahlen. Die größere Zahl wird durch die kleinere geteilt. Der auftretende Divisionsrest dient wieder als Divisor für den Divisor der ersten Rechnung. Geht die Division irgendwann einmal ohne Rest auf, ist der Teiler gefunden. Fibonacci-Zahlen Das ist der Algorithmus zur Berechnung der sogenannten Fibonacci-Zahlen, bestehend aus folgenden zwei Anweisungen:

114


왘

Die ersten beiden Zahlen der Folge sind 0 und 1.

왘

Jede folgende Zahl ist die Summe der beiden Vorgänger.

Das Programm errechnet diese Zahlen fortlaufend. Small Hierbei handelt es sich um eine kleine ENIAC-Konfiguration mit zwei Akkumulatoren, einer Starteinheit und einer Takteinheit. Ein Programm ist nicht konfiguriert. Medium Diese etwas größere Konfiguration des Rechners besteht aus einer Starteinheit und einer Takteinheit, vier Akkumulatoren und zwei Transmittern zum Speichern von Daten. Large Die Large-Konfiguration des Rechners weist folgende Komponenten auf: eine Starteinheit und eine Takteinheit, acht Akkumulatoren und zwei Transmitter. Extended large Das ist das leistungsfähigste Beispiel. Es verfügt über Start- und Takteinheit und dazu über einen Transmitter, jedoch 16 Akkumulatoren. Bis zu 20 Akkumulatoren stehen am Rechner zur Verfügung. Nachdem das gewünschte Programm gewählt ist, öffnet sich ein Fenster, das einen Blick auf den (etwas reduzierten) ENIAC zeigt. Abbildung 3.10 zeigt die Small-Version mit zwei Akkumulatoren. Natürlich kann man sich auch die weiteren Beispiele ansehen. Im Internet gibt der Entwickler der Seite die Empfehlung, sich an den Beispielen zu orientieren, wenn man den ENIAC programmieren möchte: http://www.zib.de/zuse/Inhalt/ Programme/eniac/faq.html. In der zugehörigen Diplomarbeit findet man weitere Hinweise: http://www.zib.de/zuse/Inhalt/Programme/eniac/doc/ENIAC_2005-0520.pdf und http://www.zib.de/zuse/Inhalt/Programme/eniac/doc/eniac_simulation_ thesis.pdf. Die Programmierung dieses rechnenden Wohnzimmerschranks ist nicht ganz einfach, deshalb verweise ich hier auf den Titel »Coding for Fun. IT-Geschichte zum Nachprogrammieren«, in dem die Programmierung einer einfachen Multiplikation beschrieben ist.

115

3.3

3


Abbildung 3.12

Simulation des ENIAC mit einer einfachen Rechenaufgabe

Auch wenn Ihnen die Programmierung dieses »Sauriers« nicht so ganz gelungen sein sollte, können Sie sich wenigstens die Beispiele anschauen. Man kann am Taktgeber auf einfache Weise mit dem Schieberegler die Taktrate erhöhen oder verringern. Mit dem Stepschalter lassen sich einzelne Takte absetzen, was einer Einzelschrittausführung und damit dem Debuggen entspricht. Was Debuggen eigentlich ist, werden wir bald in der Praxis erfahren. Wie bereits gesagt: Machen Sie sich nichts daraus, wenn Ihnen der ENIAC nicht recht gehorchen will, auch unser Dr. Seltsam, der geniale österreichisch-ungarische Computerwissenschaftler John von Neumann, soll damit seine Probleme gehabt haben. Man erzählt sich die Geschichte, dass er den Rechner einmal einen ganzen Tag arbeiten ließ, bis er feststellte, dass alle Ergebnisse falsch waren, weil ein Stecker nicht richtig stach. Dabei muss man ihm neidlos zugestehen, dass er ein Hochbegabter, wenn nicht gar ein Genie gewesen ist. Er besaß ein fotografisches Gedächtnis, das es ihm gestattete, ganze Buchseiten praktisch mit einem Blick auswendig zu lernen. So konnte er auch Goethes Faust aus dem Gedächtnis aufsagen. Während seines gesamten Lebens setzte er sich mit den vielseitigsten Problemen der Physik und Mathematik auseinander und löste viele wissenschaftliche Rätsel. Hierbei ging er völlig selbstlos vor und half bereitwillig jedem Wis-

116


senschaftskollegen, ohne auf sein Urheberrecht zu bestehen. Als er schließlich an Krebs starb, den er sich vermutlich durch seine langjährige Mitarbeit am amerikanischen Atombombenprogramm zugezogen hatte, standen Tag und Nacht Wachen vor seiner Krankenzimmertür, weil man befürchtete, er könne im Todeskampf noch militärische Geheimnisse ausplaudern. Arbeitsweise des ENIAC Für den Start des ENIAC mussten zunächst alle Komponenten einzeln eingeschaltet werden. Danach hatten die einzelnen Komponenten – die Zählwerke mit ihren sogenannten Flipflops – beliebige zufällige Werte, die vor Beginn der Berechnungen erst einmal auf Null gestellt werden mussten. Diese Arbeit übernahm die sogenannte Initiating-Unit. An ihr war auch der Startknopf angebracht, mit dem die einprogrammierten Programme gestartet wurden. Damit wurde die Cycling Unit in Betrieb genommen, die Taktimpulse an die einzelnen Komponenten sendete. Dieser Takt ist notwendig, damit die berechnenden Bausteine regelmäßig ihre Zustände ändern können und dabei Rechenvorgänge durchführen. Das galt für den ENIAC und gilt so auch noch für moderne Rechner. Genau diese Taktgeschwindigkeit ist der Gigahertz-Wert, der bei jedem Rechner angegeben wird. ENIAC arbeitete mit 100 kHz, hatte aber auch die Möglichkeit, einzelne Impulse abzugeben, so dass sich die Arbeitsschritte genau nachvollziehen ließen, um eventuelle Programmierfehler leichter zu entdecken. Die wichtigste Komponente des ENIAC war der sogenannte Akkumulator. Er ist bis heute ein sehr wichtiger allgemeiner Baustein im Prozessor von Computern. In einem solchen modernen Prozessor begegnen wir ihm in Form der Akkumulator-Register (Kürzel AL, AH, AX oder EAX). 8*5+2 ist eine ganz einfache Berechnung aus zwei Schritten. Zum Errechnen des Ergebnisses wird zuerst 8 mit 5 multipliziert und zum Ergebnis dann 2 addiert. Wir erhalten also ein Zwischenergebnis, das gleich wieder in den nächsten Rechenschritt einfließt. Genau das realisiert der Akkumulator. In ihn wird das Ergebnis einer Rechnung gelegt, und beim nächsten Schritt wird mit dem Inhalt des Akkumulators weitergerechnet. Realisiert ist das im Prozessor durch eine feste Verdrahtung mit dem Eingang der Recheneinheit; zugleich ist er aber auch mit dem Ausgang verbunden, so landet das Ergebnis der Berechnungen auch stets im Akkumulator. Bei der Programmierung wird eine Variable, die Zwischenergebnisse speichert, manchmal ebenfalls als Akkumulator bezeichnet.

117

3.3

3


Die Akkumulatoren des ENIAC konnten jeweils eine bis zu zehn Stellen umfassende Dezimalzahl speichern, addieren oder subtrahieren. Dafür benötigten sie erstaunlich kurze 0,2 Millisekunden, da sie mit Röhren arbeiteten statt mit Relais. Um genauere Berechnungen durchführen zu können, ließen sich je zwei Akkumulatoren zusammenschalten. Außer mit dem Akkumulator konnten auch noch mit dem sogenannten Multiplikator für Multiplikationen und dem Divider/ Square-Rooter (Divisionen und Wurzelziehen) Berechnungen durchgeführt werden. Komplexere Berechnungen wurden von einer Master-Programmeinheit durchgeführt, von der es zwei Stück gab. Einen echten Hauptspeicher hatte der Rechner dagegen nicht. Vor allem aber wurde er nicht durch gespeicherte Befehle gesteuert. Es gab jedoch Einheiten zum Lesen und Schreiben von Lochkarten, die zur Ablage der Ergebnisdaten dienten. Angezeigt wurden die Rechenergebnisse direkt beim Rechnen in den Akkumulatoren. Zu diesem Zweck gab es in ihrem oberen Teil zehn Reihen von jeweils zehn Birnchen und zwei zusätzliche Glühbirnen für das Vorzeichen. Die gesamte Programmierung musste mit Kabeln gesteckt oder durch Schalter eingestellt werden. Dabei waren die in Kniehöhe verlaufenden Kabel, die sogenannten Program Trays für die Übertragung der Programmimpulse zuständig. Die Digit Trays für die Übertragung der Zahlwerte verliefen dagegen in Kopfhöhe. An allen Trays gab es entsprechende Steckdosen, die über Kabel mit den Steckdosen an den Komponenten verbunden werden konnten. Diese Art der Programmierung fand erst ein Ende, nachdem von Neumann 1948 den ersten Elektronenrechner der Welt mit einem Befehlsspeicher ausstatten ließ.

3.4

UNIVAC – ein Computer schreibt Wahlgeschichte

Wenn die Programmierung des ENIAC auch stark an eine alte Telefonvermittlung erinnert, so schritt die Entwicklung des Computers danach doch rasant fort. Schon das nächste Modell von Eckert und Mauchley, der erste in Serie gebaute Computer UNIVAC von 1951, sollte ebenfalls Computergeschichte schreiben. Im Jahr 1952 stand die Präsidentschaftswahl an, die bereits im Vorfeld äußerst spannend war. Es wurde ein Kopf-an-Kopf-Rennen zwischen dem ehemaligen General Dwight D. Eisenhower (der Ursprung der Familie Eisenhauer liegt in der Eisenindustrie-Region des heutigen Saarlandes) und Stevenson, dem Gouverneur von Illinois. Man hatte beschlossen, durch eine Hochrechnung mit dem neuen UNIVAC die Wähler möglichst früh über den Ausgang der Wahl zu informieren. Daraus wurde ein gewaltiges Medienspektakel, jeder Sender wollte bei der Bekanntgabe des Ergebnisses dabei sein. 118

Frei nach Turing: die Manchester Mark I

UNIVAC wurde mit 5 % der Auszählung programmiert und prognostizierte einen klaren Sieg für Eisenhower. Die Enttäuschung war groß, jeder war der Meinung, dass Stevenson gewinnen würde. Man nannte den Rechner eine geistlose und dumme Maschine und beachtete das Ergebnis nicht mehr. Als die Auszählungen jedoch beendet waren, hatte der Rechner Recht behalten, und ganz Amerika war perplex. Mit einem Paukenschlag war der Computer in die Öffentlichkeit getreten und sollte daraus nicht mehr wegzudenken sein. Wer die Zeichen der Zeit verstand und damals IBM-Aktien kaufte, konnte damit reich werden. »Ich schwöre nach wie vor auf meinen Hund. Kein Computer hat sich je bei seinem Programmierer fürs Fresschen bedankt oder Männchen gemacht.« – Anonymus

3.5


Neben von Neumann war Alan Turing einer der größten Computerwissenschaftler der »Gründerzeit«. Er hatte sich wie von Neumann über den prinzipiellen Aufbau von Rechnern Gedanken gemacht. Während des Krieges arbeitete er ebenfalls an der Entschlüsselung der deutschen Enigma-Maschinen mit. Alan Mathison Turing (geb. am 23.6.1912 in London, gest. am 7.6.1954 in Wilmslow) Alan Turing ist eine der größten Persönlichkeiten in der Geschichte der Informatik. Und das, obwohl es zu der Zeit, als er seine wichtigsten Arbeiten abschloss, Computer im heutigen Sinne noch gar nicht gab. Er war ein hochbegabter Kryptologe, Mathematiker und Logiker. Seine theoretischen Arbeiten zum Computer sind die wichtigsten Grundlagen der theoretischen Informatik. Auf ihn geht der Turing-Test zurück, der sich mit der Unterscheidung Mensch/Maschine befasst und zum Nachweis künstlicher Intelligenz dienen soll, sowie die Turingmaschine, die die Leistungsfähigkeit einer Rechenmaschine darstellt. Turing hat federführend an der Entschlüsselung des deutschen Enigma-Codes im Zweiten Weltkrieg mitgearbeitet und das erste Schachprogramm für Computer geschrieben. Alan Turing war der Sohn von Julius Mathison Turing und Ethel Turing. Schon sehr früh fiel auf, dass Alan hochbegabt war, brachte er sich doch angeblich innerhalb von vier Wochen selbst das Lesen bei und beschäftigte sich außerdem viel mit Rätseln. Mit sechs Jahren besuchte er die Ganztagsschule in St. Michaels. Auch hier fiel seine Begabung auf, wie auch am Malborough College, das er danach besuchte. Mit 14 Jahren, also 1926, wechselte er auf das Sherborne-Internat von Dorset.

119

3.5

3


Während er in den naturwissenschaftlichen Fächern herausragende Leistungen zeigte, hatte er in den geisteswissenschaftlichen frappierende Schwächen. Aus diesem Grund versiebte er einige Prüfungen und bekam einen schlechten Notendurchschnitt, was dazu führte, dass er lediglich das King's College besuchen konnte (von 1931 bis 1936), während er gerne am Trinity College studiert hätte. 1936 veröffentlichte er seine mathematische Arbeit »On Computable Numbers, with an Application to the Entscheidungsproblem«, die sich mit dem Gödelschen Entscheidungsproblem auseinandersetzte. In dieser Arbeit formulierte er auch die 1-Band-Turingmaschine, die statt einer Folge von Formeln für die prinzipielle Berechenbarkeit steht. Im Prinzip kann man sich eine Turingmaschine als Papierstreifen, Bleistift und Radiergummi vorstellen. Der Streifen erzwingt ein sequentielles Vorgehen. Turing bewies in seiner Arbeit, dass ein solches Gebilde ein universeller Automat ist. Was bedeutet, dass sich damit alle denkbaren Rechenprozesse nachvollziehen lassen – selbst unlösbare Aufgaben, die dazu führen, dass die Turingmaschine niemals anhält. Lösbare Probleme führen dazu, dass sie nach einer endlichen Zeitspanne stehenbleibt. 1938 und 1939 studierte Turing an der Princeton University, wobei er bereits 1938 dort seinen Doktor zum Thema Hypercomputation und Orakel-Maschinen (erweiterte Turingmaschinen) machte. Während des Zweiten Weltkriegs arbeitete er an der Entschlüsselung verschiedener Geheimcodes mit, unter anderem an dem der Enigma. Seine dabei erzielten Erfolge waren im Grunde kriegsentscheidend. Kurz vor seinem Tod 1954 befasste sich Turing mit Biologie und den dort vorkommenden mathematischen Zusammenhängen. Doch das große Computergenie hatte auch eine private Seite, die man zur damaligen Zeit noch nicht tolerieren wollte – er war homosexuell veranlagt. 1952 brach ein junger Mann, zu dem er eine Beziehung hatte, mit einem Komplizen in sein Haus ein. Turing meldete einen Diebstahl. Bei den Ermittlungen kamen jedoch seine sexuellen Vorlieben ans Licht. Wegen »grober Unzucht und sexueller Perversion« wurde er daraufhin angeklagt. Er verzichtete jedoch auf seine Verteidigung und wurde verurteilt. Er erhielt die Wahl zwischen Gefängnis und Therapie. Die Therapie, die er gewählt hatte, führte infolge von hohen Östrogendosen zu Depressionen und zur Bildung von Brüsten. Man fand ihn schließlich tot auf seinem Bett, neben einem halb gegessenen, mit Zyanid vergifteten Apfel. Allgemein wird angenommen, dass es Selbstmord war, auch wenn seine Mutter immer behauptete, er sei sehr sorglos mit Chemikalien umgegangen. Angeblich ist die makabre Geschichte vom Ende des großen Computergenies die Grundlage für den Firmennamen Apple und das Logo mit dem angebissenen Apfel.

120


Entwicklung der Manchester Mark I Alan Turing lehrte ab 1948 an der Universität in Manchester. Weil die theoretischen Grundlagen des Computers teilweise auf Turing zurückgehen, war man an der Schule bestrebt, während seiner Lehrtätigkeit ebenfalls über einen Rechner zu verfügen. Schließlich gab es noch keine kommerziellen Computer zu kaufen, daher wurde der Bau eines Rechners geplant. 1948 wurde zunächst ein Prototyp gebaut, die Small-Scale Experimental Machine. Die Weiterentwicklung dieses Rechners erhielt den Namen Manchester Mark I. Ein problematisches Bauteil bei den ersten Großrechnern war immer der Arbeitsspeicher. Bei den ersten Zuse-Maschinen waren es die Relais, die durch ihre jeweilige Schaltstellung den Inhalt des Arbeitsspeichers abbildeten. Beim Bau von Arbeitsspeichern galt es zwei Hürden zu nehmen: Einmal musste die in den Arbeitsspeicher übertragene Information darin auch erhalten bleiben, zum anderen sollte die Information rasch eingelesen und genauso schnell auch wieder ausgelesen werden können. Beide Anforderungen widersprechen sich, und dieses Problem konnte bis heute noch nicht wirklich zufriedenstellend gelöst werden. Sehr schneller Speicher verliert in der Regel auch seinen Inhalt wieder sehr rasch. Und nicht flüchtiger Speicher arbeitet meist auch sehr langsam. Unsere heutigen Speicherbausteine lassen sich folgendermaßen einteilen: 왘

DRAM ist zwar sehr schnell, muss jedoch ständig aufgefrischt werden, damit keine Daten verloren gehen.

왘

Der heute weit verbreitete Flash-Speicher auf Karten für Kameras oder Sticks für den Rechner ist zwar nicht flüchtig, aber wesentlich langsamer als DRAMBausteine, außerdem verbraucht er sich mit der Zeit.

Zu Zeiten von Turing gab es natürlich weder die einen noch die anderen Speicherchips, aber es gab Röhren. Eine Röhrenform, die Williams-Kilburn-Röhre, besaß interessante Eigenschaften: Traf der Elektronenstrahl auf die fluoreszierende Schicht, so leuchtete der Lichtpunkt eine Weile nach. Und solange er nachleuchtete, konnte er wieder ausgelesen werden. Anschließend ging die Information allerdings verloren. Um die Röhre effektiv nutzen zu können, mussten die Lichtpunke ständig aufgefrischt werden, so, wie es heute noch mit den Refreshzyklen der DRAM-Bausteine üblich ist. Außerdem musste die Williams-KilburnRöhre von Hand feinjustiert werden. Einen Vorteil hatte die Röhre allerdings: Der Inhalt des Arbeitsspeichers war direkt sichtbar. Man konnte sehen, ob und wie der Rechner gerade arbeitete.

121

3.5


Somit ist der Manchester Mark I ein interessanter Rechner, den man sich einmal ansehen sollte. An seiner Entwicklung arbeitete übrigens ein Mathematiker-Ehepaar mit, dessen Sohn, Tim Berners-Lee, später am CERN das WWW entwickeln sollte.

Quelle: www.google.com

3

Abbildung 3.13

Der Ferranti Mark I mit Röhren als Arbeitsspeicher

Aus dem Manchester Mark I wurde der Ferranti Mark I (siehe Abbildung 3.11) entwickelt, der zweite kommerzielle Computer der Welt. Praxis: Baby, Baby ... Auch vom Manchester Mark I finden sich Simulationsprogramme im Internet. Eine interessante Webseite zu diesem Gerät ist die Jubiläumsseite zum 60-jährigen Jubiläum des Rechners: http://www.cs.manchester.ac.uk/Digital60/Baby/ ssem/index.htm Natürlich gibt es auf der DVD ebenfalls eine Simulation unter Software zum Buch\Kap03\Manchester Mark 1\Sim02\baby.zip. Entpacken Sie den Inhalt der zip-Datei in einem Ordner auf der Festplatte. Gestartet wird das Java-Programm, indem Sie auf der Konsole in den Ordner simulator wechseln. Dort geben Sie »java Baby« ein und drücken (¢). Wichtig ist es, »Baby« mit großem Anfangsbuchstaben zu schreiben. Zwei Dialogfenster werden geöffnet.

122


Abbildung 3.14

Manchester Baby Simulator von David Sharp

Das erste Fenster gewährt einen Blick auf die Williams-Kilburn-Röhre des Hauptspeichers. Überall, wo ein hellgrüner Punkt zu sehen ist, steht im Hauptspeicher eine 1, und dort, wo der Punkt nur schwach ist, eine 0. Auch wenn es etwas ungewöhnlich scheint, was man da sieht, es ist ein lauffähiges Programm. Das zeigt sich, wenn man auf die Schaltfläche Run klickt. Abhängig von dem jeweiligen Programm leuchtet die rote Lampe links auf, die anzeigt, dass der Rechner das Programm durchlaufen hat. Oder die Lampe geht nie an, wenn das Programm in einer Endlosschleife unaufhörlich durchläuft, solange man es nicht mit der Stop-Schaltfläche anhält. Natürlich kann man Programme schlecht in Form von Punkten oder als 00110110111 eingeben. Das ist jene berühmt-berüchtigte Maschinensprache, deretwegen Assembler erfunden wurde. Eine solche Assembler-Sprache gibt es auch für diese Simulation. Sie ist nicht sonderlich komplex, weil es sich um einen einfachen Rechner handelt. Sie kennt im Grunde nur sieben Instruktionen. Um sie zu verstehen, muss man wissen, dass es zwei Steuerungsinstruktoren gibt, die Controllinstruction (CI), also die Zeile mit dem aktuellen Befehl, der gerade ausgeführt wird, und die Presentinstruction (PI), der aktuelle Befehl. 왘

JMP kopiert den Wert aus der angegebenen Zeile in den CI

왘

JRP addiert den Wert aus der Zeile zum CI

왘

LDN kopiert den Inhalt der angegebenen Zeile negativ in den Akkumulator

왘

STO kopiert den Inhalt des Akkumulators in die genannte Speicherzeile

123

3.5

3


왘

SUB subtrahiert den Inhalt der genannten Zeile vom Akkumulator

왘

CMP inkrementiert4 den Ci, wenn der Inhalt des Akkus kleiner 0 ist

왘

STP hält den Rechner an und lässt die Stopplampe aufleuchten

Während man mit Step schrittweise durch ein Programm geht, kann man den Disassembler nutzen: View 폷 Disassembler. Der Disassembler zeigt am oberen Rand CI, PI und den Akkumulator an. Mit Load from Store kann man sich jederzeit den Speicherinhalt in den Debugger holen. Man kann ihn editieren und mit Save to Store wieder zurückspeichern. Die Programmierung des Mark I ist also ganz einfach: Texteditor geöffnet und folgende Assembler-Zeilen eingetippt sowie als Datei mit der Endung .asm abgespeichert: 30 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 24 25 26 27 28

NUM CMP SUB STO LDN SUB NUM LDN STO LDN SUB CMP LDN STO SUB STO JMP NUM NUM NUM NUM NUM NUM NUM NUM NUM NUM

-671072229 18 21 21 21 -671064037 1 21 21 20 19 1 22 7 1 1207943145 -134217729 805289958 -8192 -2 -2139094978 -2139095040 -2139095026 1078149664 1078215200

4 Erhöht um den Wert 1.

124

; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;

LDN 27 49152 32786 24597 16405 32789 STO 27 16385 24597 16405 32788 49152 16403 24577 32790 24583 1 SUB 9 STP SUB 6 STP STP JMP 30 JMP 0 JMP 14 LDN 0 LDN 0

Der Rechner geht in Serie: Innovation made by IBM

29 30 31

NUM 1074020896 NUM 1078215616 NUM -2

; LDN 0 ; LDN 0 ; STP

Die Zeilennummern werden mit angegeben, sie sind auch die Nummern der Speicherstellen. Die Anweisung NUM zeigt an, dass es sich bei der Speicherstelle nicht um einen Befehl, sondern um Daten handelt. Eine ausführlichere Anleitung finden Sie im Internet: http://www.davidsharp.com/baby/babyuserguide.pdf.

3.6


Der Zweite Weltkrieg war zu Ende, und überall wurden die Kriegsschäden beseitigt. Die Leute begannen wieder, ihrem Broterwerb nachzugehen. Es entstanden sogar neue Berufe – wie der des Programmierers. Überall wurden diese neuen Maschinen benötigt, die man »Computer« getauft hatte. Keine Versicherung und keine Bank wollte darauf verzichten. In Deutschland war es Konrad Zuse, der mit seiner Zuse AG Computer baute, und in Frankreich Bull sowie in Amerika IBM, die beide zuvor schon mit Tabelliermaschinen Geld verdient hatten. Aber auch andere Unternehmen, wie Hitachi in Japan, sollten sich noch daran versuchen. Computer bauen war eine große Herausforderung. Man musste elektrisch und mechanisch hohe Qualität liefern, und es war viel Kapital erforderlich. Dass IBM Qualität liefern konnte, hatte man schon früher bewiesen. Ja, auch folgendes Produkt stammt von IBM (siehe Abbildung 3.13). IBM hatte sehr schnell erkannt, dass man Rechner nicht wie Uhren, Brötchen oder Autos verkaufen kann. Noch wichtiger als die Maschine selbst war der Service. So machte IBM daraus eine Passion. Mit dem Kauf oder der Miete (Leasing) der Maschine schloss man einen Wartungsvertrag ab. Dieser sorgte dafür, dass die Maschine regelmäßig gewartet wurde (siehe Abbildung 3.14). Der Mann, der die Firma Computing-Tabulating-Recording Company (CTR) in IBM (International Business Machines Corporation) umbenannte und sie an die Weltspitze führte, hieß Thomas J. Watson (1874–1956). Er entstammte einer tiefreligiösen schottischen Auswandererfamilie und absolvierte seine kurze Ausbildung an der Miller School of Commerce, einer Handelsschule. Als Verkäufer war er eine Naturbegabung, er griff allerdings auch zu unlauteren Methoden, die ihn fast ins Gefängnis brachten. Er hatte bei NCR billig defekte Registriermaschinen verkauft, die bald kaputtgingen und gleich durch neue, teure ersetzt werden sollten. Seit 1914 arbeitete er in der Firma, die er in IBM umtaufte. Seine Ideen und Methoden wurden legendär. Den Aufruf »Think«, den er zum Wahlspruch für seine Mitarbeiter machte, hatte er bereits bei NCR eingesetzt.

125

3.6


© IBM

3

Abbildung 3.15 Bild im IBM-Online-Archiv, auf der Seite für hochwertige Uhren: zwei IBMStanduhren von 1932

126

© NASA


Abbildung 3.16

Das Panel einer IBM 360-90 der NASA

Watson hatte sogar ein Gesangbuch schreiben und gemeinsame Gesangsstunden abhalten lassen, um die Kameradschaft unter den Verkaufsmitarbeitern zu festigen. Eines seiner Produkte, der PC, macht es möglich, einmal hineinzuhören: http://www-03.ibm.com/ibm/history/multimedia/wav/everonward.wav. Er besaß 31 Ehrendoktorwürden und wurde 1937 zum WelthandelskammerPräsidenten gewählt. 1943 soll er den berühmten Ausspruch getan haben: »Es gibt auf der Welt höchstens Bedarf für fünf Computer.« Echte Computer brachten schon mit der ersten Baureihe, dem IBM 650, mehr Geld ein als alle Uhren und Lochkarten-Sortiermaschinen zusammen. Ein guter Verkäufer darf sich auch mal irren. Global gesehen war IBM schon immer mit Zähl- und Addiermaschinen im Markt. Bereits 1946 hatte man den elektronischen Rechenstanzer IBM 604 entwickelt. Dessen Nachfolger, der Rechenstanzer IBM 604 hatte bereits ein Rechenwerk mit 1.400 Elektronenröhren. Er wurde mit Hilfe einer Schalttafel gesteuert/programmiert. Da die Anwender umfangreichere Programme wünschten, kam man auf die Idee, Lochkarten für die Programme zu nutzen, und entwickelte 1949 den CPC, den Card Programmed Calculator. Richtige Computer waren das alle noch nicht, wenn man von dem IBM Mark I einmal absieht. Aber man konnte es sich leisten. Tabelliermaschinen baute man schon seit 1896, und diese Zählapparate waren eine gute Grundlage, um auch beim Computerbau erfolgreich zu werden.

127

3.6


© IBM

3

Abbildung 3.17

Der Harvard Mark I – IBMs ASCC

Aikens Mark I Der Computer hieß eigentlich IBM Automatic Sequence Controlled Calculator oder kurz IBM ASCC, man nannte ihn aber auch IBM Mark I. Er wurde am 7. 8.1944 an der Harvard University der Öffentlichkeit vorgestellt, fertig war er bereits 1943. Der Rechner war 15,50 Meter lang, 2,50 Meter hoch und wog fünf Tonnen. Die Entwickler Howard Aiken, Clair D. Lake, Frank E. Hamilton, Benjamin M. Durfee und James W. Bryce hatten ihn aus 3.300 Relais und 2.200 Zählrädern sowie insgesamt ca. 700.000 Einzelteilen und 80 km Kabel zusammenbauen lassen. Die Programme lagen beim ASCC nicht im Hauptspeicher, sondern wurden per Lochstreifen ausgeführt. Man spricht von der externen Programmsteuerung. Damit war der ASCC eigentlich kein Von-Neumann-Rechner. In Harvard war er 15 Jahre in Betrieb, später wurde er nur noch als Harvard Mark I bezeichnet.

1955 wurde der erste über einen Hauptspeicher programmierbare Computer von IBM entwickelt, der IBM 650. Noch immer waren Rechner Unikate, von denen jedes Modell seine eigenen Programme benötigte. Doch das sollte sich ändern. IBM gab 1960 eine Untersuchung in Auftrag, die das frühe EDV-Wesen vollständig verändern sollte. Der SPREAD-Report von Systems, Programming, Review, Engineering And Development erzeugte 1961 die Idee, eine Computerfamilie zu

128


bauen, deren Bandlaufwerke und sonstige Peripherie gleich und austauschbar sein sollte, ebenso die Software, die dazu auf einem Betriebssystem zu laufen hatte. Die IBM-Vertriebsmitarbeiter fanden solche Ideen verrückt. Für sie konnte es nur nachteilig sein, wenn die Komponenten der Rechner austauschbar wären, und wie sollte das mit der Software funktionieren? Sein Vater hätte dem vielleicht noch beigepflichtet, Thomas Watson jun. aber erkannte den Wert solcher Ideen und übernahm die Verantwortung für die Neuerungen. Mit über fünf Milliarden Dollar stellte man ein Entwicklungsprojekt auf die Beine, das in der Industriegeschichte seinesgleichen sucht. Am Ende arbeiteten über 50.000 Menschen an der Entwicklung des Systems /360. Der Name stand für den Vollkreis von 360 Grad. So, wie der Kreis die vollkommene Fläche ist, so sollte die /360 der vollkommene Rechner werden. Das Computerzeitalter hatte begonnen: Waren Rechner früher Einzelstücke, wurden sie nun am Fließband hergestellt. In 78 Städten gleichzeitig wurde am 07.04.1964 auf der ganzen Welt der Verkaufsstart des Systems /360 eingeläutet. Es gab sechs Modelle mit vierzig verschiedenen Peripheriegeräten (siehe Abbildung 3.14). Das Computerzeitalter hatte begonnen – mit all seinen Träumen und Verrücktheiten. War doch schon das kleinste Modell des Systems, die /360-30, 43-mal schneller und mit 66-mal mehr Arbeitsspeicher ausgestattet als die IBM 650. Natürlich machte dies das Rechnen auch billiger. Zumindest, wenn man die Kosten pro Rechnertakt angab. In Wirklichkeit hatte die IBM 650 noch 3.500 $ Monatsmiete gekostet, die /36030 kostete 7.000 $. Auf den /360-Mainframe, wie man Großrechner auch nennt, folgte 1970 die /370 und 1990 das System S/390, woraus sich das System z als 64-Bit-Architektur entwickelte. Die z-Serie ist die aktuelle Großrechnergeneration bei IBM. Rechenzentren gibt es zwar noch immer, aber ihre Innenausstattung ist eine völlig andere. Wo früher geschäftig Operatoren mit Lochkartenstapeln vom Kartenstanzer zum Kartenleser hasteten, gibt es heute nur noch Racks mit endlosen Reihen an flachen, herausziehbaren Servern. Damals waren es die großen drehenden, augenähnlichen Spulen der Bandlaufwerke, die einen anstarrten, die Sortierer, die ratternd die Karten in ihren Fächern mischten. Die Kartenstapel, die von einem Gerät zum anderen getragen wurden, immer in der Angst, mal einen fallen zu lassen und das Durcheinander der Lochkarten wieder in Ordnung bringen zu müssen. Die Schnelldrucker, die ihre langen Papierzungen zusammenfalteten. Abends konnte man dann seinen Packen abholen, wenn man die Dumps und Ausdrucke der erstellten Software durchsehen wollte. Jede Fahne trug oben in großer Schrift den Jobnamen, damit der Operator wusste, wo er das 129

3.6

3


Endlospapier abreißen musste. Die Fahnen wurden dann kreuzweise übereinandergestapelt. Oder in das Fach des Programmierers gelegt, wenn es denn so etwas gab. Eine eigene Welt, einem kleinen Betrieb nicht unähnlich, der CPUZeit verkaufte, die sorgfältig verwaltet und für jeden Batchjob peinlich genau ausgerechnet und in Rechnung gestellt wurde. Eine Welt, die längst vergangen ist, die wir aber dank des Computers virtuell wiederauferstehen lassen können. Praxis I: Mainframe in the Box Nun sind unsere heimischen PCs inzwischen so leistungsfähig, dass selbst ihre Grafikkarten mehr Speicher haben als die wohnzimmerschrankgroßen Rechenmonster von damals. Was liegt also näher, als die Großrechner mit einem PC zu simulieren? Bereits IBM hat diesen Weg gesehen, insbesondere für Software, die nicht mehr von den aktuellen Großrechnermodellen unterstützt wird. So gab es bis 2007 die Emulations-Software FLEX-ES der Firma Fundamental Software. IBM hat einige der Betriebssysteme lizenziert. Natürlich muss man beides käuflich erworben haben, um es nutzen zu dürfen. Es gibt zum Glück eine weitere Simulation, die sich Hercules nennt und die man aus dem Netz herunterladen darf. Ein /360- oder gar System z-Betriebssystem darf man darauf allerdings nicht betreiben. Starten wir also unseren Großrechner. Das Hochfahren, das früher eine gute Viertelstunde dauerte, ist heute in wenigen Sekunden erledigt. Hercules ist die Simulation einer IBM /370 und ESA/390 für den PC unter den Betriebssystemen Linux, Windows, FreeBSD, Mac OS X und Solaris, entwickelt von Roger Bowler, Jay Maynard und Jan Jaeger. Man findet das Programm im Netz unter http://www.hercules-390.org/. Es befindet sich auch auf der DVD des Buches: Software zum Buch\Kap03\Ibm360\Hercules. Dort liegt für das jeweilige Betriebssystem eine Version. Startet man das Programm, fragt es nach einem Verzeichnis, in das die Dateien entpackt werden können. Nach dem Entpacken kann man aus der Konsole heraus den Emulator starten. Dazu wechseln Sie z. B. unter Windows in das Verzeichnis /hercules-3.06 und rufen die Datei hercules.exe auf. Auf der Konsole erscheint eine Textausgabe, die den Status der Simulation anzeigt. Sie entspricht in etwa dem, was ein Administrator an der Adminkonsole zu sehen bekommt, wenn er eine wirkliche IBM-Maschine hochgefahren hat. Natürlich wird ihm auch angezeigt, welche Software, also welches Betriebssystem, welcher TSO (Time Sharing Option; auf Deutsch: Kommandozeileninterpreter) und welcher Transaktionsmonitor gestartet wurde.

130


Abbildung 3.18

Blick auf die Kommandozeile des Hercules /360

Diese Konsole stellt den eigentlichen Rechner (IBM 370) ohne Betriebssystem dar und dient der Administration. Durch Eingeben eines: ?

werden einem die möglichen Befehle angezeigt. Mit den Tasten (Bild½) und (Bild¼) lässt sich in der Liste der Befehle blättern. Als Großrechnernutzer kann man zumindest theoretisch mehr als einen Prozessor verwenden. Man gibt folgenden Befehl ein, um sich das anzusehen: cfall (¢)

(Dieser Befehl funktioniert nicht auf der Volker Bandke's Turnkey MVS Windows ISO Image Version.) cfall steht für »konfiguriere alle CPUs«. Wahrscheinlich werden Sie über eine

CPU nicht hinauskommen. Auch ein Emulator kann nicht herbeizaubern, was nicht vorhanden ist. Mit pwd kann man sich die Position im Verzeichnisbaum ausgeben lassen (print work directory), mit cd kann man wie in der Windows- oder DOS-Konsole üblich das Verzeichnis wechseln. Es gibt eine weitere Ansicht, auf der zusätzliche Informationen, insbesondere zu den verfügbaren Terminals, angezeigt werden. Man erreicht sie über die (Esc)Taste.

131

3.6

3


Mit einem entsprechenden Terminalprogramm können Sie sich den Startscreen des Minigroßrechners ansehen, z. B. mit dem Programm Software zum Buch\ Installationen\Terminals\tneval32.exe. Es ist nur eine eingeschränkte Version zum Testen (siehe Abbildung 3.17). Als Port müssen Sie 3270 nutzen.

Abbildung 3.19

Terminalkonsole an Herkules

Es gibt außerdem noch die Möglichkeit, die Adminkonsole per Webzugriff zu nutzen. Dazu dient der Port 8081, z. B. in dieser Form: http://localhost:8081/

Das soll nur ein erster Blick gewesen sein. Die Arbeit an einem Großrechner ist nicht gerade einfach, und Hercules ist nicht einfach irgendeine Simulation zum Spielen. Sie wird von vielen Firmen genutzt, um die alten /360- oder /370-Programme, auf die man eventuell noch angewiesen ist, weiter zu betreiben. Statt mit dem Großrechner einfach mit einem Server in Form eines PCs – das das geht, haben Sie eben gesehen. Der PC ist gegenüber einem Großrechner aus den 80ern eben doch eine Art Supercomputer. »Früher waren Computer noch nützlich, sie heizten den Rechnersaal.« – Kurt Jungels

132


Praxis II: Betriebssysteme und Zusatzprogramme für IBM-Maschinen Ganz ohne echtes Betriebssystem und Zusatzprogramme, wie Compiler für die eine oder andere Programmiersprache, macht das alles wenig Spaß. Deshalb gibt es die sogenannte IBM Public Domain Software Collection, die man über folgende Internetadresse erreicht: http://www.ibiblio.org/jmaynard/ Dort sind einige Betriebssysteme für die großen IBM-Maschinen verfügbar. Interessant ist auch Volker Bandke's Turnkey MVS, eine CD-ISO, auf der alles enthalten ist, was man benötigt: der Hercules-Emulator sowie ein MVS 3.8jBetriebssystem. Diese ISO-Datei befindet sich im gepackten Zustand auf der Buch-DVD unter Software zum Buch\Kap03\Ibm360\Turnkey-MVS\turnkey-mvs-3.zip. Diese Datei muss entpackt werden, um die turnkey-mvs-3.iso zu erhalten. Sollten Sie nicht über einen Entpacker verfügen, so finden Sie auch diesen auf der Buch-DVD, und zwar unter Software zum Buch\Tools\Packer\fz306.exe. Nach der Installation des Fz306 kann man die zip-Datei entpacken und die enthaltene ISO auf eine Silberscheibe brennen. Fehlt es auch am Brennprogrammm, so springt ein Programm von der Buch DVD-ein: Software zum Buch\Tools\ Brennsoftware\bao0995.exe. Die gebrannte DVD-ROM ist keine Boot-DVD, sondern eine DVD, die man unter Windows und Linux nutzen kann, um eine IBM-Großrechnersimulation auf dem PC zu installieren. Auf der DVD-ROM befindet sich eine Datei readme.html, die Sie mit einem Browser öffnen können, um die Dokumentation einzusehen. Dort befindet sich auch die umfangreiche Dokumentation zur Installation. Die Installation unter Windows beginnen Sie durch einen Doppelklick auf der Datei Setup.bat. Es wird gefragt, welches MVS eingerichtet werden soll. Sinnvoll ist 1. Standard Setup, weil beim Simple Setup keine Drucker initialisiert werden. Die nächste Frage ist mit Y (yes) zu beantworten, damit die eigentliche Hercules-Simulationssoftware überhaupt installiert wird. Danach wird der Prozessor angegeben – im Zweifelsfalle i568 – und dahinter der Thread ftthread. Im Weiteren wird nach der Installation der grafischen Konsole HercGUI gefragt. Da sie interessant ist, sollte man hier ebenfalls Y eingeben. Jetzt geht es mit Y weiter, Cygwin ist eine notwendige Linux-Umgebung für Windows. Beim Terminalemulator geben wir ein Y ein. Die nächste Frage bezieht sich auf das Instal-

133

3.6

3


lationsverzeichnis. Gibt man nichts ein, wird unter C:\programme\mvs38j installiert. In der folgenden Frage geht es sozusagen um die virtuellen Großrechnerfestplatten. Es ist sinnvoll, die Dateien mit 2 auf die Platte zu kopieren. Die Quellen braucht man nicht, also wählen Sie N, während Sie SMP (System Modification Program) installieren können. Es ist sozusagen ein Updatemanagement-Systemkonfigurationstool. CBT kann man ebenfalls kopieren, das Startersystem sowieso. Den Konsolenport lassen Sie am besten auf 3270, den Socket Reader Device Port auf 3505 und den Webport auf 8081. Im lokalen Betrieb bietet sich an, nicht den Computernamen, sondern localhost, also 2, zu wählen. So kann man beim nächsten Y mit (¢) die Installation einleiten. Nach dem Kopieren der Dateien und dem Anlegen der Verzeichnisse bestätigen Sie mit der (¢)-Taste. Es werden eine 3270-Masterkonsolen eine 3215-Masterkonsolen drei 3270-Terminalkonsolen eingerichtet. Diese Zahlen lassen sich ändern, was jedoch für die einfache Testumgebung zu diesem Buch nicht erforderlich ist. Das Setup des Socket Readers wird als Nächstes durchgeführt. Bestätigen Sie nochmals, geben Sie das Passwort »SECRET« ein, und drücken Sie die (¢)-Taste. Danach ist die Installation abgeschlossen. Nach der Installation finden Sie auf dem PC im Verzeichnis Programme das Unterverzeichnis mvs38j. Dort gibt es eine Reihe Batchdateien, also Dateien mit der Endung .bat. Mit der startmvs.bat fahren Sie den Großrechner hoch, die Mainframe-Konsole öffnet sich. Sie hat die Portnummer 3215. Ihren Dialog kennen wir schon aus dem Experiment mit Hercules (siehe Abbildung 3.16). Danach starten Sie ein paar Terminals mit Hilfe von startterm.bat. Damit ist der Großrechner nun sozusagen hochgefahren, und einige Terminals sind eingeschaltet. Im nächsten Schritt wird das MVS, das Betriebssystem, gestartet. Das geschieht über einen sogenannten Bootstrap Prozess oder, wie es beim IBM Mainframe heißt, Initial Program Load (IPL). Dazu geben Sie auf der Mainframe-Konsole »ipl 148« ein. Command ==> ipl 148

134


Es ist die Anweisung für den Rechner vom Device (Gerät/Festplatte) 148 ab dem Track 0, Record 0 zu lesen. Genau an dieser Stelle ist das MVS gespeichert. Ein paar Meldungen werden angezeigt. CPU0000: SIGP CPU0001 Initial program reset PARM 00000000 000C:CCW=03000000 20000001=>040E0000 00041572 00000000 00000000 .... ............ 000C:Stat=0E00 Count=0001 000C:Sense=40000000 00000000 00000000 00000000 00000000 00000000 000C:Sense=INTREQ

Eine der sechs gestarteten Konsolen ist die MVS-Master-Konsole, mit der das Betriebssystem gesteuert werden kann. Es ist das Device mit dem Port 3270 und der Nummer 0010, die jedoch in der Dialogbox nicht mehr angezeigt wird. Dass sie gestartet ist, sieht man an einer Meldung auf der Mainframe-Konsole: a1 connected to 3270 device 0010

Auf dieser Konsole steht der Cursor am unteren Rand links, während am oberen Rand steht: SPECIFY SYSTEM PARAMETERS FOR RELEASE ..., was hilft, sie zu finden.

Abbildung 3.20

Die MVS-Masterkonsole

Auf dieser Konsole gibt man nun Folgendes ein: r 00,clpa

und bestätigt mit der (¢)-Taste. Hier müssen wir nun eine Zäsur machen. Das System verhält sich anders, wenn wir es zum ersten Mal starten. Wenn sich das Bild aus Abbildung 3.19 aufbaut, ist alles ok. Anders als beim ersten Start erhalten wir nämlich diese Meldung:

135

3.6

3


IEE360I SMF NOW RECORDING ON SYS1.MANX ON MVSRES TIME=22.01.38 IGF992I MIH INIT COMPLETE, PRI=000300, SEC=000015 IEF677I WARNING MESSAGE(S) FOR JOB JES2 ISSUED *00 $HASP479 UNABLE TO OBTAIN CKPT DATA SET LOCK - IO ERROR * REPLY Y OR N TO CONTINUE

Wir geben das gewünschte y in dieser Form ein: r 00,y

Wahrscheinlich wird sich nun JES2 ganz verabschieden und melden: ... - $HASP085 JES2 TERMINATION COMPLETE

Wir starten JES2 nun mit: s jes2

Was eine weitere Warnung auf die Konsole zaubern sollte: IEF677I WARNING MESSAGE(S) FOR JOB JES2 ISSUED *01 $HASP426 SPECIFY OPTIONS - HASP-II, VERSION JES2 4.1

Wir kontern: r 01,format,noreq

Nun sollte JES2 im Startvorgang fortfahren und auf der anderen Konsole melden: *02 $HASP479 UNABLE TO OBTAIN CKPT DATA SET LOCK - IO ERRORREPLY Y OR N TO CONTINUE IEF6771 WARNING MESSAGE(S) FOR JOB JES2 ISSUED

Es geht weiter mit: r 02,y

Worauf diese Meldung sichtbar wird: IEE600I REPLY TO 02 IS;SUPPRESSED *03 $HASP436 REPLY Y OR N TO CONFIRM CHECKPOINT RECORD CHANGE

Wir bestätigen mit: r 03,y

Nun sollte JES2 vollständig starten, was eine Reihe Meldungen nach sich zieht. Am Ende sollte stehen: ALL AVAILABLE FUNCTIONS COMPLETE

136


Ab diesem Punkt laufen wir wieder mit dem Startvorgang konform, der abläuft, wenn wir nicht das erste Mal starten (siehe Abbildung 3.19).

Abbildung 3.21

JES2 ist gestartet

Gleichzeitig wird eine Logon-Konsole aktiviert. Das ist die Konsole, die der normale Nutzer zu sehen bekommt, wenn er sein Terminal einschaltet, um sich einzuloggen (siehe Abbildung 3.21). Es kann sein, dass nicht immer alle Terminals aktiviert werden. Also heißt es, ein wenig zu experimentieren.

Abbildung 3.22

JES2-Konsole

Was nun noch aktiviert werden muss, sind die Drucker. Sie sind bei Hercules natürlich nur virtuell, und zwar in Form von Dateien, in die Hercules seine Dru-

137

3.6

3


ckerfahnen hineinschreibt. Die Drucker werden in der JES-Konsole aktiviert (siehe Abbildung 3.20), und zwar mit dem Befehl $SPRINTER

gefolgt von der Druckernummer. Man sollte beide Drucker aktivieren, also etwa: $SPRINTER1 $SPRINTER2

Die Vollzugsmeldung sieht unter Umständen recht einfach aus, meist werden jedoch Statusmeldungen gedruckt (siehe Abbildung 3.20): $HASP000 OK

Dass die Drucker »angelaufen sind«, erkennt man am besten im Verzeichnis mvs38j\prt. Die beiden darin enthaltenen Dateien haben nicht mehr die Dateilänge Null. User Nun wechseln wir die Person und werden vom Administrator zu einem einfachen Nutzer. Nehmen wir einen der existierenden Usernamen, und loggen wir uns ein, z. B. so: Logon ==> IBMUSER

Mit Logoff kann man sich übrigens wieder ausloggen. Als weitere User stehen HERC01 bis HERC04 zur Verfügung. Auf dem Terminal erscheint ein READY. Es besagt, dass wir im Usermodus sind und der Rechner für Eingaben bereit ist. Mit HELP gelangt man in einen Editor mit Hilfetexten. Und so blättern Sie in den Hilfetexten (gescrollt wird mit vier Funktionstasten): Taste

Funktion

(F7)

nach oben scrollen

(F8)

nach unten scrollen

(F10)

nach links scrollen

(F11)

nach rechts scrollen

(ÿ_)

feldweise nach unten wandern

(¢)

in die Kommandozeile springen

Tabelle 3.2

138

Blättern in den Hilfetexten


Abbildung 3.23

Einloggen bitte!

Achtung Es kann sein, dass die Konsolen nicht richtig aktiviert werden. Also bleiben die Userkonsolen schwarz. In solch einem Fall hilft es meist, JES2 und MVS regulär herunterzufahren und neu zu starten: 1. JES-prozesse alle stoppen mit: $P 2. Kontrollieren der Prozesse, Jobs und Statistiken mit D A,L $DA $DU

3. JES2 mit $pjes2 in der JES-Konsole beenden 4. Mit Hilfe von Z EOD eine Statistik ausgeben 5. MVS mit f bsppilot,shutnow in einer der beiden MVS-Konsolen beenden. 6. Hercules mit QUIT in der Adminkonsole herunterfahren und mit der (¢)-Taste schließen.

Vom allgemeinen Vorgehen zum Assembler-Programm Um ein Volume5 oder eine Datei anzulegen, ist es sinnvoll, nicht den IBMUSER zu verwenden, sondern einen der Standarduser wie HERC01 oder HERC03. Beim MVS wird eine Datei übrigens als Dataset bezeichnet. Das ist einfach die Bezeichnung für Großrechnerdateien. Ein Name für solch eine Datei kann bis zu 44 Zeichen lang sein und Punkte enthalten. Man spricht von Qualifiern, die durch Punkte getrennt sind. Der letzte Qualifier steht dabei für den Dateityp. Jeder Qualifier kann bis zu 8 Zeichen lang sein. Die Namen von Katalogen (Catalogs) sind genauso aufgebaut. Man kann sie sich als Listen vorstellen, in die Datasets

5 Das, was man früher mit »Volume« bezeichnete, ist heute in etwa eine Festplatte bei Windows.

139

3.6

3


eingetragen werden. Die Datasets, die im globalen und die im privaten Katalog stehen, kann man bearbeiten. Um die eigenen Dateien anzuzeigen, verwendet man LISTCAT, das sozusagen für »List private Catalog« steht. IN CATALOG:SYS1.UCAT.TSO HERC01.CMDPROC HERC01.TEST.ASM HERC01.TEST.CNTL HERC01.TEST.LOADLIB

Dateinamen beginnen immer mit dem Nutzernamen, z. B. HERC01, danach folgen ein Punkt und der eigentliche Dateiname. Hinter dem zweiten Punkt kommt die Typenbezeichnung der Datei, z. B. DATA, ASM oder CNTL. Kennt man den Namen nicht genau, kann man Jokerzeichen einsetzen: LISTCAT ENTRY(TEST.*)

Nun erhält man den Dataset-Namen und den Katalog angezeigt. Möchte man ein Dataset allokieren, so gelingt das zum Beispiel für das Dataset HERC01.CODING .ASM über: ALLOC DATASET(CODING.ASM)

Freigeben kann man ein allokiertes Dataset mit dem Befehl FREE: FREE DATASET(CODING.ASM)

Informationen zu einem Dataset erhält man über LISTDS: LISTDS CODING.ASM

Was der Nutzer vor allem benötigt, wenn er eingeloggt ist, wäre z. B. ein Editor. Einer dieser Editoren heißt RPF. Er ist mehr eine Art IDE, mit der man gezielt Datasets anlegen oder löschen oder auch in einen Operatormodus wechseln kann. RPF steht für »Rob’s Programming Facility«. Ein anderer Editor heißt FSE (Full Screen Editor) und ist etwas einfacher. Gibt man FSE in der Befehlszeile (unter READY) ein, so fragt er nach dem Dateinamen. READY FSE ENTER DSNAME-

Wir geben einen Dateinamen ein: PROG.CODING.ASM

140


Danach folgt diese Meldung: INVALID TYPE SPECIFIED, REENTER

Geben wir DATA als Dateityp an, wird die Datei angelegt. Noch einfacher ist der Befehl EDIT, der ein Zeileneditor ist. Er ist jedoch immerhin so komfortabel, dass man damit Datasets anlegen und bequem editieren kann. Öffnet man jedoch eine bestehende Datei, springt er hinter die letzte Zeile. Möchte man die bestehenden Zeilen lesen, nutzt man den Befehl LIST. Und nun soll ein Programm geschrieben werden. Natürlich geht es darum, MORE CODING FOR FUN auf den Schnelldrucker zu jagen. EDIT CODING.DATA

Oder nennen Sie Data als Dateityp. Das Programm oder besser die Jobkarte mit dem enthaltenen JCL und Assembler-Code sieht so aus: 001 002 003 004 005 006 007 008 009 010 011 012 013 014

//ASMFCLG JOB CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1),REGION=128K //CODING EXEC ASMFCLG //ASM.SYSUT1 DD UNIT=SYSDA //ASM.SYSUT2 DD UNIT=SYSDA //ASM.SYSUT3 DD UNIT=SYSDA //ASM.SYSGO DD UNIT=SYSDA //ASM.SYSIN DD * CODING CSECT USING CODING,15 SAVE (14,12) WTO 'MORE CODING FOR FUN' RETURN (14,12),RC=0 END //

Aus dem EDIT-Modus kommt man mit der (F3)-Taste, jetzt gibt man SAVE ein zum Speichern und END, um den Editor zu beenden. Wenn das JCL-Dataset abgespeichert ist, wird es mit SUB CODING.DATA ausgeführt. Auf der JES-Konsole wird die Ausführung des Batchjobs gemeldet mit: IEFACTRT Stepname Procstep

Program

Retcode

ASMFCLG

CODING

ASM

IFOX00

REC= 0012

ASMFCLG

CODING

LKED

IEWL

*FLUSH*

ASMFCLG

CODING

GO

PGM=*.DD

*FLUSH*

141

3.6

3


Abbildung 3.24

Das Assembler-Programm im EDIT-Editor

Abbildung 3.25

Das Assembler-Programm im FSE-Editor

Nun sieht man sich die Druckfahne des ersten Druckers an. IEF236I ALLOC. FOR ASMFCLG GO CODING IEF237I 190 ALLOCATED TO PGM=*.DD CODING FOR FUN IEF142I ASMFCLG GO CODING - STEP WAS EXECUTED - COND CODE 0000

Die Meldungen sagen uns: STEP WAS EXECUTED – das Programm wurde ausgeführt – und COND CODE 0000 – der Condition Code war 0, was für eine fehlerfreie Ausführung steht. Sollten Fehler aufgetreten sein, die mit einem ERROR in der Druckerfahne unter der jeweiligen fehlerhaften Programmzeile kenntlich gemacht werden, so behebt man sie und macht ein neues SUBMIT.

142


Abbildung 3.26

JES-Meldungen zum Compiler, Linkerlauf und Programmstart

Abbildung 3.27 Die Druckerfahne, auf der die mit dem Programm geschriebene Zeile grau hinterlegt ist

Befehl

Wirkung

CANCEL

Job abbrechen – Jobname oder JobID

LISTCAT

Zeigt die Dateien im User-Katalog an.

Tabelle 3.3

MVS-Befehlsübersicht

143

3.6

3


Befehl

Wirkung

DEFINE ALIAS Name Oldname Catalog

Definiert einen Alias für ein Dataset.

LISTCAT ALIAS

Zeigt den Alias und den Katalog.

LISTALC

Zeigt alle allocierten Datasets.

DELETE

Löscht das genannte Dataset.

TEST

Testet ein Programm.

HELP FSE

Leistet Hilfe zum FSE.

$p

Stoppt alle JES-Prozesse.

D A,L

Zeigt Systemjobs an.

$DA

Zeigt aktive Jobs an.

$DU

Zeigt aktive Prozesse an.

$pjes2

Fährt JES herunter.

Z EOD

Gibt Statistiken aus.

QUIESCE

Leert den Puffer.

f bsppilot,shutnow

Fährt MVS herunter.

Tabelle 3.3

MVS-Befehlsübersicht (Forts.)

»Die Prähistoriker in ferner Zukunft werden sich totsuchen nach dem Missing Link von Mensch zu Computer.« – Erhard Blanck (*1942), deutscher Heilpraktiker, Schriftsteller und Maler

3.7

Lesen Sie weiter

Quellen [1] Konrad Zuse: Der Computer – Mein Lebenswerk. Springer Verlag. 1984 Webseiten zum Kapitel URL

Beschreibung

http://user.cs.tu-berlin.de/~zuse/history/ HNF-PNN.PDF

Dokument zur Geschichte der Computer von Prof. Zuse

http://www.zib.de/zuse/Inhalt/Programme/ Simulationen von Zuse-Rechnern Simulationen/index.html

144

Lesen Sie weiter

URL

Beschreibung

http://www.zib.de/zuse/Inhalt/Programme/ Simulation der Z3 Simulationen/Z3_Sim/index.html http://www.heise.de/newsticker/meldung/ Beeindruckender-Colossus-196730.html

Bericht über den Colossus-Nachbau

http://www.codesandciphers.org.uk/

Seite zum National Museum of Computing

http://www.sharenator.com/ Retro_delight_Gallery_of_early_computers/

Galerie alter Rechner

http://www.codesandciphers.org.uk/ anoraks/lorenz/tools/

Colossus-Code und -Simulationen

http://www.seas.upenn.edu/~museum/

ENIAC-Online-Museum

http://www.computer50.org/index.html

Mark I-Seite

http://www.computer50.org/kgill/mark1/ progman.html

Programmierhandbuch für den Manchester Mark I

http://www.cs.manchester.ac.uk/Digital60/ Simulation des Mark I Baby/ssem/index.htm http://www.digital60.org/

Jubiläum des Manchester Mark I

http://www-03.ibm.com/ibm/history/ exhibits/cc/cc_room.html

IBM-Uhrenseite

http://www.users.cloud9.net/~bradmcc/ ibmsongbook.html

IBM-Gesangbuch

http://www.heise.de/newsticker/meldung/ Thomas-Watson-Jr-Von-der-Tabelliermaschine-zu-IBMs-System-360-91241.html

Artikel zur IBM-Computergeschichte

http://www.hercules-390.org/

Simulation des Hercules-IBM-Großrechners

http://www.ibiblio.org/jmaynard/

IBM Public Domain Software

http://www.bsp-gmbh.com/turnkey/ cookbook/

Link zum MVS-Cookbook

http://www.bsp-gmbh.com/hercules/ index.shtml

BSP-MVS-Homepage

http://www.schaefernet.de/hercules/ mvssoft.htm

Dokumentationen zu Hercules

http://www.schaefernet.de/hercules/ mvsbindoc.htm

Anleitung zum Einrichten und Nutzen von MVS

http://www.jaymoseley.com/hercules/ tsotutor/tsotutor.htm

MVS Tutorial

145

3.7

URL

Beschreibung

http://www.lascon.co.uk/d012001.htm

MVS Catalog-Infos

http://www.muraleedharan.com/ mainframe_mvs_catalog.html

MVS-Dateisystem

http://www.jaymoseley.com/hercules/ installmvs/mvsfaq.htm

Community-Seite zu MVS

http://hercules.clemporium.com/QSub1/ index.php

virtueller IBM-Kartenleser

Literatur zum Kapitel Precht, Manfred: EDV Grundwissen. Addison-Wesley. München 2007. Frey, Gerd: Spiele mit dem Computer. Smart Books. Kilchberg 2004.

Der wirkliche Siegeszug des Computers begann damit, dass er zum alltäglichen Gebrauchsgegenstand wurde. Kein Begriff verdeutlicht dies so sehr wie der Name »Homecomputer«. Er stellte zwar nur ein kurzes Intermezzo in der Geschichte der EDV dar, doch durch seinen Nachfolger, den PC, gewann der Computer seine heutige Bedeutung.

4

Von Äpfeln und Brotkästen

1960

1976 1977

1979

1981 1982

2000

PDP1 Apple1 Apple2 Homecomputer C64 IBM-PC

4.1

Vom Rechensaurier zum Minicomputer

Der Computer war längst etabliert und sogar Held zahlreicher Filme geworden (wie z. B. Tron1), aber trotzdem war er noch immer unnahbar. Irgendwo in klimatisierten Räumen, gepflegt von weißbekittelten Fachleuten, fristete er ein Dasein wie das eines Knastbruders, das tagein, tagaus im Abarbeiten endloser Zahlenreihen bestand.

1 Regie: Steven Lisberger, SF Film, Disney Studios, USA, 1982, 96 Minuten.

147

4


Es war Mitte der 70er Jahre des vorigen Jahrhunderts, als sich dieser Umstand radikal verändern sollte. Es keimte die Idee, Computer für den Normalverbraucher zu bauen und so klein zu machen, dass man sie überall hin mitnehmen konnte. Für den Laien sah diese Entwicklung zunächst so aus, als gäbe es da ein paar Elektronikbastler, die gerne mal wissen wollten, wie so ein Rechner mit Bits und Bytes funktioniert. Dass sich daraus einmal der größte Markt für Elektronikprodukte entwickeln sollte war absolute Fiktion. Die sogenannten ICs waren bezahlbar geworden, und es gab Bausätze für einfache Taschenrechner. Warum dann nicht auch für Computer, also für Rechner, die etwas mehr konnten, als nur Zahlen zu addieren? Kleinere Computer gab es längst, die sogenannte Middleware. Middleware Middleware war nicht mehr auf klimatisierte Räume von der Größe eines Ballsaals angewiesen. Die Minicomputer waren verkleinerte Ausgaben der »Rechensaurier«. Anfangs bestanden sie aus den gleichen Bausteinen wie ihre großen Vettern, hatten daher bei weitem nicht die gleiche Leistung wie sie. Die Firma Digital Equipment Corporation (DEC) hatte 1960 den PDP-1 genannten ersten Minicomputer auf den Markt gebracht. Der Entwickler des Rechners war ein gewisser Ben Gurley.

Für heutige Verhältnisse waren sie keineswegs mini, hatten sie doch die Größe von Kleiderschränken. Sie schrumpften jedoch weiter, am Ende immerhin bis auf die Größe von Nachtschränkchen. Die Minicomputer waren vor allem bei Universitäten und Forschungseinrichtungen sehr beliebt, weil sie um einiges billiger waren als Großrechner und nicht alle im Batchbetrieb liefen, sondern oft im Dialogbetrieb. Man nannte diese Rechnergruppe nach dem Aufkommen der Mikrocomputer Mittlere Datentechnik (midrange computer) oder einfach Middleware (heute versteht man etwas ganz anderes darunter2). Sehr bekannte Rechnermodelle dieser Klasse waren die VAX-Rechner (siehe Abbildung 4.2). Sie galten als eine Art Mini-Supercomputer und waren besonders für die grafische DV favorisiert.

2 Middleware ist Software, die zwischen Anwendungen liegt – Software, die beispielsweise Klassen einer Anwendung für die Persistrierung auf eine relationale Datenbank mappt.

148

Quelle: http://de.academic.ru/dic.nsf/dewiki/1067512


PDP-1 mit Fernschreiber als Eingabegerät und Monitor

Abbildung 4.2

Eine VAX 11/750

Quelle: www.cca.org/photo/rcsri/index.html

Abbildung 4.1

149

4.1


Gegen Ende dieser Entwicklung gab es Miniausführungen der VAX-Hardware, die sogenannte Microvax (siehe Abbildung 4.3), einer Art Super-PC.

Quelle: www.classiccmp.org/dunfield/dec/index.htm

4

Abbildung 4.3

MicroVAX 2

Praxis: Assembler mit dem PDP-1 Auch PDP- und VAX-Rechner lassen sich am PC emulieren. Es gibt sogar eine Software, die zur Emulation einer ganzen Reihe von Groß- und Minirechnern geeignet ist. Man findet sie im Netz unter http://simh.trailing-edge.com/. Die Software liegt auch auf der beiliegenden DVD unter Software zum Buch\Kap04\ Simhv-Multisimulator\simhv38-1-exe.zip. Entpackt man die Datei, findet man eine ganze Reihe exe-Dateien. Zu jedem Rechnermodell gibt es einen eigenen, selbständig laufenden Emulator. Aber auch hier gilt: Neben dem Emulator werden die jeweiligen Betriebssysteme benötigt. Die Einrichtung ist zudem extrem aufwendig und umfangreich. Eine Beschreibung würde in diesem Buch mehr als ein ganzes Kapitel füllen. Aus diesem Grund möchte ich hier auf die Dokumentationen verweisen, die sich zu diesem Thema im Internet befinden. Eine sehr gute Beschreibung zur Einrichtung eines VAX-Systems unter Linux findet man auf dieser Webseite: http://www.wherry.com/gadgets/retrocomputing/ vax-simh.html. Trotzdem wollen wir natürlich auf einen Versuch mit einem der ersten Minicomputer nicht verzichten. Auch dazu können wir auf eine professionelle Simulation zurückgreifen. Sie nennt sich ersatz11 und ist in einer kostenlosen Demoversion erhältlich. Auf der folgenden Seite erfahren Sie mehr: http://www.dbit.com. Die Software befindet sich mit einer ausführlichen Dokumentation auch auf der DVD unter Software zum Buch\Kap04\PDP11.

150


Diese Software sollte man in jedem Fall auf einem virtuellen Rechner installieren. Es kann zu Virenwarnungen kommen, da der Code des Emulators Codeteile enthält, die von vielen Virenschutzprogrammen als Virus erkannt werden. Möchte man trotzdem die besprochenen Versuche durchführen, muss man den Virenschutz etwas lockern. Dadurch könnten sich echte Viren unbemerkt einschleichen. Auf einem virtuellen System ist man bei entsprechend vorsichtiger Handhabe jedoch auf der sicheren Seite, wenn man das System nach den Versuchen löscht. Nach dem Start der exe-Datei wird eine einfache Installationsroutine aufgerufen und die Software auf der Platte des virtuellen Rechners installiert. Das eigentliche Simulationsprogramm ist die E11.exe.

Abbildung 4.4

Assembler-Programmierung mit der PDP11

In unserem kleinen Programm geht es darum, einen kurzen Satz auf dem Bildschirm auszugeben (siehe Abbildung 4.4). Die Befehlsübersicht des Emulators kann man sich mit einem ? holen. Allerdings muss man bedenken, dass die Tastatur nicht entsprechend der deutschen Tastatur belegt ist. Das Fragezeichen ist dort, wo das (#) ist. Alternativ kann man auch HELP eintippen. Mit der ersten Zeile kündigen wir der »Shell« an, dass wir ein Assembler-Programm ab der Speicherstelle 1000 schreiben wollen. Das geht mit ASSEMBLE <Speicherstelle> oder a <Speicherstelle>. E11> a 1000

151

4.1

4


Nun wird vorne die Speicheradresse angezeigt. Der Editor des Assemblers ist bereit. Wir speichern die Adresse des Textes, der ausgegeben werden soll, im Register 5: 001000 mov #1022,r5

Danach wird der Port für die Zeichenausgabe überwacht. Ist er frei, geben wir sogleich den Text aus. tst steht für Test: 001004 tstb @#177564

Ist das Ergebnis positiv, gehen wir zu 1004 zurück, um auf ein negatives Ergebnis zu warten. bpl steht dabei für »branch if plus«, also »verzweige nach, wenn plus«. 001010 bpl 1004

Gibt die Zeile mit dem tstb ein negatives Ergebnis aus, kann das Programm demnach zur Speicherstelle 001012 gelangen. An dieser Stelle steht nun der Code für die eigentliche Ausgabe des Textes: 001012 movb (r5)+,@#177566

Was so viel besagt wie, dass der Prozessor den Inhalt der Speicherstelle, die in Register 5 steht, auf den Ausgabeport legen soll. Danach soll er den Inhalt des Registers um 1 erhöhen. Gleichzeitig soll der Erfolg der Operation im ConditionCode-Register (Flagregister) festgehalten werden. 001016 bne 1004

Dies gilt es mit dem nächsten Befehl zu überprüfen, wobei bne für »branch if not equal” steht. Verzweige, solange ungleich. Bringt 001012 eine Null, wird die nächste Speicherstelle angesprungen und das Programm angehalten. 001020 halt

Die folgende Zeile sorgt dafür, dass der gewünschte Text in dem Arbeitsspeicher ab Speicherstelle 1022 abgelegt wird. Der Text kann dabei bis 32 Zeichen lang sein. Das Programm läuft so weit durch den Speicher, bis keine vernünftigen Zeichen mehr vorhanden sind und eine Null (00) kommt. und stehen für einen Zeilenumbruch und den Wagenrücklauf. 001022 .asciz /Beispiel aus More Coding for Fun/

Mit den Tasten (Strg)+(C) kann man den Assembler-Modus verlassen. 001040 ^C

152

4.2

Der Biss in den Apfel

Um das Programm ablaufen so lassen, muss man den Prozessor anweisen, die Befehle ab Speicherstelle 1000 abzuarbeiten. Das gelingt mit einem einfachen Go <Speicherstelle> für »gehe zur genannten Speicherstelle«. g 1000

4.2


Quelle: www.edibleapple.com

Die Firma Apple, die heute der angesehenste Computerhersteller der Welt ist, wurde als Garagenfirma von Steve Jobs, Steve Wozniak und Ronald Wayne am 1. April 1976 im heutigen Silicon Valley, Los Altos, gegründet. Bedenkt man, dass die 1.750 US-Dollar zur Gründung aus dem Verkauf von Steve Jobs HippieVW-Bus und Wozniaks Hewlett-Packard-Taschenrechner stammten – wobei man sich heute nicht mehr einig ist, ob der Taschenrechner oder der VW-Bus mehr einbrachte –, war es wohl eher eine Art Aprilscherz als die Hoffnung, eine Firma mit Milliardenumsatz (oder wie man in Big Apple, New York City, sagt: »Billion in sales«) zu gründen.

Abbildung 4.5

Wozniak und Jobs mit dem Motherboard des Apple I

Der Apple I war ein Bausatz ohne Netzteil, Tastatur und Gehäuse, genau so, wie man es bis dahin von Taschenrechnern für den Selbstbau kannte. Es gab auch fer-

153


tig verlötete Exemplare zu kaufen. Entworfen hatte die Platine Steve Wozniak, Jobs hatte von diesen technischen Details nicht genug Ahnung, um selbst eine Platine entwickeln zu können. Aber er verstand etwas von dem, was technisch machbar war und beim Kunden ankam.

Quelle: www.applefritter.com

4

Abbildung 4.6

Das Motherboard des Apple I

Die Platine kostete damals 666.66 US-Dollar3, was relativ viel war für einen Selbstbausatz (siehe Abbildung 4.6). Wichtige Teile fehlten, wie das Netzteil und eine Tastatur. So wurden insgesamt nur einige Hundert Exemplare der Apple IPlatine verkauft.

4.2.1

Steve Jobs versus The Beatles

Vor der Gründung der Firma musste man sich über einen Namen einig werden. Obwohl es ein wichtiger Teil der Unternehmensgeschichte ist, so ist man sich selbst bei Apple nicht mehr einig, wie der Name eigentlich entstand ist. Steve Jobs, den die Suche nach Erleuchtung bereits nach Indien geführt hatte – was zur Zeit der Blumenkinder durchaus nichts Ungewöhnliches war –, verbrachte hin und wieder einige Wochen auf der Farm seiner Hippiefreunde und half dabei auch bei der Apfelernte. Andererseits war der Name Apple Records für jeden Beatles-Fan ein Begriff. Es war das Plattenlabel dieser Band. Jobs hatte zu der Zeit, als ihn seine Sehnsucht nach Indien führte, bei Atari gearbeitet und kannte die Wirkung eines Namens mit dem Anfangsbuchstaben A. Er landete ganz vorne 3 http://apple1.chez.com/Apple1project/Gallery/Gallery.htm (Mystiker sehen in dem verrückten Preis ein böses Omen.)

154


im Branchenverzeichnis des Telefonbuchs, aber auch in der normalen örtlichen Übersicht. Wenn man nun vor Atari landen wollte, war Apple als Name gerade richtig. Steve Wozniak wandte natürlich sofort ein, dass es Ärger mit Apple Records geben würde, als Jobs den Namen vorschlug. Und er sollte Recht behalten. 1989 verklagte Apple Records Apple Computer auf Verletzung des Markennamens, was Apple schlussendlich zu einer Zahlung von 26,5 Millionen $ zwang. Allerdings ging es weniger allein um den Namen Apple. Bereits 1981 hatte man sich geeinigt, dass Apple Computer seinen Namen führen dürfte, wenn man 80.000 $ zahlen würde und versichere, dass man sich ganz aus dem Musikgeschäft heraushalte. Nun bot der neue Apple-Rechner aber die Möglichkeit, Musik mit dem CDROM-Laufwerk zu kopieren, was Apple Records als eindeutigen Verstoß gegen die alte Abmachung ansah. Die Millionen wurden gezahlt. Der Streit war damit jedoch nicht beigelegt, Apple Computer entwickelte sich weiter. Als man schließlich den iPod als MP3-Player auf den Markt brachte und eine zugehörige Musikbörse, iTunes Store, im Internet etablierte, war der nächste Gerichtstermin absehbar. Die Firma Apple Corps Ltd. gehörte inzwischen Paul McCartney, Ringo Starr, Yoko Ono, der Witwe von John Lennon, sowie den Erben von George Harrison. Man brachte jedoch 2007 eine endgültige Einigung zustande, bei der Apple Computer den Markennamen Apple ganz übernahmen und in Apple Inc. umfirmierte. Von Steve Jobs Firma wurde eine Summe in ungenannter Höhe gezahlt und Apple Records gestattet, den Namen bezüglich der Musikstücke weiter nutzen zu dürfen. Was die Herkunft des Namens angeht, sind die Ungereimtheiten nach wie vor unausgeräumt. So grassiert im Internet auch folgende Geschichte, die angeblich von Steve Jobs selbst stammt: »Damals war ich tatsächlich noch Frutarier, aß nur Obst. Mittlerweile bin ich, wie jeder andere auch, ein Abfalleimer. Wir waren damals mit der Anmeldung unseres Unternehmensnamens drei Monate im Verzug, und ich drohte, das Unternehmen 'Apple Computer' zu nennen, falls bis fünf Uhr niemandem ein interessanterer Name einfällt. Ich hoffte, so die Kreativität anzuheizen. Aber der Name blieb. Und deshalb heißen wir heute ›Apple‹.« – Quelle: wikipedia.de

155

4.2

4


4.2.2

Der erste PC

Die Gewinne aus dem Apple I-Verkauf reichten aus, um das Nachfolgemodell, den Apple II, entwickeln zu können. Der Apple II wurde ein Riesenerfolg, und der Grundstein zu einem Weltunternehmen war gelegt (bis 1985 wurde er zwei Millionen Mal verkauft). In Amerika gilt er heute als der erste persönliche Computer, der erste PC.

Abbildung 4.7

Der Apple II Plus mit Monitor

Neben zahlreichen revolutionären Leistungsdaten hatte der Apple II eine Eigenschaft, die sich erst später bei einem anderen Hersteller als entscheidendes Merkmal herausstellen sollte: Der Apple II war mit Hilfe von Steckkarten erweiterbar. Er war demnach ein offenes System. Ein Teil der Funktionsweise und des Bauplans wurde veröffentlicht, so dass andere Hersteller Platinen entwickeln konnten, die die Fähigkeiten des Rechners verändern konnten. Hatte man z. B. vor, einen Scanner zu betreiben, so gab es eine Karte, an die ein Scanner anschließbar war, auch wenn die Standardanschlüsse des Apple II dies nicht zuließen. Wollte man Temperaturen erfassen, um einen Brutschrank für bedrohte Vogelarten zu steuern, so war auch das über eine spezielle Input/Output-Steckkarte möglich.

156


Praxis: Die Apple I-Computerplatine Der Apple I war nicht viel mehr als eine Platine und deshalb ohne eigenen Bastelgroßeinsatz kaum zu nutzen. Um dieses Feeling entsprechend vermitteln zu können, soll hier ein entsprechend spartanisches Beispiel mit dem Apple I-Emulator Pom herhalten. Wir nehmen sozusagen die nackte Platine und zaubern mit ihr »Coding for Fun« auf den »Fernsehbildschirm«. Das nötige Programm findet man im Internet unter http://pom1.sourceforge.net/ aber auch auf der Buch-DVD unter Software zum Buch\Kap04\Apple\pom10.0.3-win32.zip. Nach dem Entpacken können Sie das Programm POM1.EXE starten. Es erscheinen zwei schwarze Dialogboxen. Eine davon besitzt einen Cursor und stellt den Fernsehbildschirm dar, der an die Apple I-Platine angeschlossen ist. Eingaben sind, wie üblich, mit der Tastatur möglich. Informationen zu Steueranweisungen finden Sie in der Datei README.txt. Mit zwei durch einen Punkt getrennte Adressen können Sie den Speicher ausgeben lassen, z. B.: 01F8.020F

Programmieren sollte man den Apple I natürlich in Maschinensprache, wobei wir nur einen Text ausgeben. Wir kopieren also einen Hauptspeicherinhalt in den Videospeicher. Dazu schreiben wir Folgendes in den Hauptspeicher: 0300: 0308: 0310: 0318: 0320:

A2 07 4C 4E 55

00 20 1F 47 4E

BD EF FF 20 00

13 FF 8D 46 00

03 E8 43 4F 00

C9 4C 4F 52 00

00 02 44 20 00

F0 03 49 46 00

Nun müssen wir nur noch den Instruktions-Pointer4 auf die 0300 stellen, damit der Prozessor die danach folgenden Befehle abarbeitet. Das macht man mit dem Befehl R in dieser Form: 0300R

Als Ergebnis erhalten wir das gewünschte »Coding for Fun«. Wer seine Versuche nicht nur eintippen will, der kann Speicherinhalte mit (Ctrl)+(S) in eine Datei auslagern oder mit (Ctrl)+(L) laden. Angefangene Befehle können mit der (Esc)4 Das Befehlszählregister ist eine Speicherstelle im Prozessor, die je nach Systemarchitektur die Speicheradresse des aktuellen oder des als Nächstes auszuführenden Befehls enthält.

157

4.2

4


Taste unterbrochen werden. Das gezeigte Beispiel finden Sie auch als ASCII-Textdatei auf der DVD unter Software zum Buch\Kap04\Apple\coding.txt. Man kopiert die Datei ins Pom1-Verzeichnis und lädt sie mit Hilfe von Ctrl-L Coding.txt A 0300R

Mit dem Apple I waren also durchaus erste Erfahrungen in Richtung Computerprogrammierung möglich. Wer das noch vertiefen möchte, der findet im Internet reichlich Informationen über den Aufbau und die Programmierung der Apple IPlatine.

4.2.3

Ein Tag im November

Entscheidend für die Zukunft des Computerherstellers Apple sollte ein Tag im Spätherbst des Jahres 1979 werden. Steve Jobs war vom Xerox-Entwicklungslabor zu einer kleinen privaten Vorführung eingeladen worden. Mit einigen Mitarbeitern und natürlich auch Wozniak schaute er sich dort einen Rechner an, den man Xerox Alto nannte. Welch bleibenden Eindruck dieser Rechner bei Steve Jobs hinterlassen hat, gestand er 1996 in einem Interview: »Ich war total geblendet von dem ersten Ding, das sie mir zeigten: die grafische Benutzeroberfläche. Ich dachte, das ist das beste Ding, was ich je in meinem Leben gesehen habe. Es hatte noch viele Schwächen. Was wir sahen, war unvollständig. Sie hatten eine ganze Reihe Sachen falsch gemacht. Aber zu der Zeit wussten wir das nicht. Dennoch: Sie hatten den Keim der Idee geschaffen, und sie hatten es sehr gut gemacht. Und innerhalb von zehn Minuten war mir klar, dass eines Tages alle Computer so arbeiten würden.« Die damalige Vorführung bei Xerox gilt als eines der denkwürdigsten Ereignisse in der Geschichte der EDV, zumal auch Bill Gates die gleiche Anlage besichtigen durfte. Man geht davon aus, dass sowohl Apples Betriebssystem für den Rechner Lisa als auch das erste Windows auf diese Besuche zurückgehen. Die Ereignisse von damals wurden nachgestellt, und man kann sie sich im Internet als Kurzfilme ansehen, wie beispielsweise hier: http://de.sevenload.com/ videos/n593w7S-Apple-und-Xerox. Praxis: Apple Lisa Auch die »schöne« Lisa lässt sich heute am PC betrachten. Ein Emulationsprogramm findet man im Internet unter: http://lisa.sunder.net/. Auf der DVD gibt es die Windows-Version unter Software zum Buch\Kap04\Apple\AppleLisa.zip.

158


Nach dem Entpacken kopieren Sie die Dateien in ein entsprechendes Verzeichnis. Das Lisa-Office-System ist bereits installiert, so dass Sie auch direkt von der Festplatte starten können. Dazu führen Sie auf dem Dateinamen lisaem.exe einen Doppelklick aus. Ein Dialog mit der Abbildung des gesamten Lisa-Rechners wird geöffnet. Nun starten Sie über die Dialogpunkte File 폷 Run.

Quelle: http://teo-net.de/wordpress/wp-content/uploads/ 2009/01/macintosh_128k_transparency.png

Der Dialog ROMless Boot wird geöffnet. Wählen Sie ProFile Hard Drive on Parallel Port, und starten Sie mit der OK-Schaltfläche. Eine Festplatte wird gezeigt, anschließend startet das Lisa-Office-System Release 3.1.

Abbildung 4.8

Lisa-Emulator eines laufenden Apple Lisa 2-Rechners

Es ist eine einfache zweifarbige Windows-Oberfläche (siehe Abbildung 4.8). Mehr als eine Uhr und eine Zwischenablage sowie der Papierkorb sind nicht verfügbar. Das Diskettenlaufwerk wird über den Menüpunkt Housekeeping 폷 Eject Micro Diskette bedient, der natürlich nur verfügbar ist, wenn eine Diskette im Laufwerk steckt. Zusätzliche Software ist auf Disketten-Images im Verzeichnis /image verfügbar. Es handelt sich dabei um Programme wie 왘

LisaWorkshop

왘

LisaCalc

왘

LisaDraw

왘

LisaGraph

159

4.2


왘

LisaList

왘

LisaWrite

Anleitungen finden Sie in der Datei LisaEm User's Guide 1.2.5.pdf im Verzeichnis des Emulators. Es gibt sogar einen ausführlichen Einführungsfilm zum Apple Lisa im Internet aus dem Jahre 1983: http://www.youtube.com/watch?v= a4BlmsN4q2I&feature=fvw und einen Film zur Emulation: http://www.youtube.com/watch?v=dEth2JfgX3Y&feature=related.

4.2.4

Lisas trauriges Ende

Obwohl der Apple Lisa zu seiner Zeit ein technisch sehr gelungener Personalcomputer war, wurde es ein wirtschaftlicher Misserfolg. Hauptursache dafür war der extrem hohe Preis. Der Rechner kostete in Amerika 9.995 $. In Deutschland wurde er für rund 30.000 DM angeboten. Da er aus Design-Gründen eher zierlich wirkte (das Display hatte 12«), war kaum jemand bereit, einen so hohen Preis für dieses Gerät zu bezahlen. So kam es, dass Apple in einer Nacht-und-NebelAktion 2.700 Rechner auf einer Müllhalde in Utah einfach verscharren ließ. Es hatte sich als unmöglich herausgestellt, die Rechner noch zu verkaufen. Man verfiel auf die Idee, sie einfach zu vernichten, um sie wenigstens steuerlich geltend machen zu können.

Quelle: http://www.allaboutapple.com/

4

Abbildung 4.9

160

Der Apple Macintosh

Die Zeit der Homecomputer

Auch der Nachfolger war anfangs nicht viel erfolgreicher, obwohl er nicht einmal ein Viertel von dem kostete, was man für den Apple Lisa berappen musste. Nach dem Entwicklungssprung zur grafischen Oberfläche ging die Weiterentwicklung der Hardware rasant voran. Bei Apple folgte auf den Lisa der Macintosh (siehe Abbildung 4.9), der zum Power Mac weiterentwickelt wurde. Nach und nach konnte sich Apple eine solide Nische im Bereich Design und DesktopPublishing erarbeiten und bis heute immer weiter ausbauen. Die größten Erfolge errang man dann jedoch mit Design-, ja Lifestyle-Produkten wie dem iMac, dem iPod, dem iPhone und dem iPad. »Make the screen five inches by eight inches, and you'll rule the world.« – »Machen Sie das Display 5 Zoll mal 8 Zoll groß, und Sie werden die Welt erobern.« – Alan Kay zu Steve Jobs auf die Frage nach seiner Meinung zum iPhone *** »Wir lieben die Beatles, und deshalb war es schrecklich, mit ihnen wegen der Apple-Namensrechte zu streiten.« – Steve Jobs

4.3


Hier soll nicht verheimlicht werden, dass in den Achtzigern auch die große Zeit der sogenannten Homecomputer begann. Die Medien hatten den Computer hoffähig gemacht, und in den Firmen wurde er einigen Mitarbeitern auf den Schreibtisch gestellt. Die Firma Apple wollte jedoch den Computer für jedermann bauen. Aber beide, der PC aus dem Büro wie der Apple II für den betuchten Enthusiasten, waren für den Hausgebrauch viel zu teuer. In diese Marktlücke drang nach und nach eine ganze Reihe von Anbietern mit klingenden Namen. Um nur einige zu nennen: Commodore, Sinclair, Atari, Arcon, Schneider, Spectravideo und Sony. Das erfolgreichste Modell von allen war der Commodore C64. Was bei ihm überzeugte, waren Leistung und Preis. Sein Name leitete sich von seinem 64-KB-Hauptspeicher ab.

4.3.1

Mein Spectravideo

Es war ein eher verregneter Samstag im Jahre 1984. Ich hatte mich entschlossen, meinen Homecomputer (siehe Abbildung 4.10) doch zu verkaufen, nachdem ich einige Testberichte über aktuelle Computerspiele und zum Rechner geschrieben

161

4.3

4


sowie Software für den MSX-Standard entwickelt und bei gängigen Computerzeitungen in klingende Münze verwandelt hatte. Meine Hoffnung war, dafür eine jener gigantischen schwarzen Olivetti-Typenrad-Schreibmaschinen in gutem gebrauchtem Zustand zu erstehen, da sie für das Erstellen von Artikeln eindeutig besser geeignet waren als Homecomputer mit 40 Zeichen pro Zeile.

Abbildung 4.10

Der Spectravideo SV 318

Den Homecomputern musste ich trotzdem nicht entsagen, weil Philips mir einen MSX VG8020 für meine freie Mitarbeit zur Verfügung gestellt hatte.

Abbildung 4.11

Der Philips MSX VG8020

Ich hatte in der lokalen Presse eine Verkaufsanzeige aufgegeben und auch einen Interessenten gefunden, der sich an jenem Samstag erwartungsvoll bei mir einfand. Unser Gespräch verlief ziemlich zwiespältig, was mir sofort, dem Käufer jedoch überhaupt nicht bewusst wurde.

162


»Ich bin Architekt und habe jeden Tag eine Menge Pläne zu zeichnen, auch 3D-Darstellungen der geplanten Gebäude sind gefordert, was mir hin und wieder Kopfschmerzen bereitet. Der Bauherr hätte am liebsten ein Foto von seinem zukünftigen Haus, am besten mit Umgebung, Bäumen, architektonischem und landschaftlichem Hintergrund, Bewölkung und so weiter.« »Gewiss, aber der Rechner hat eine grafische Auflösung von 256 × 192 Punkten bei 16 Farben.« »Außerdem sind da noch die statischen Berechnungen.« »Nur wird es schwerlich dafür Programme geben. MSX-BASIC ist im ROM enthalten und erlaubt eine recht komfortable Programmierung.« »Ach, ja, das ist schön, eine Programmiersprache wollte ich immer schon erlernen. Es ist doch sicher nicht all zu schwer. Gewiss kann man sie in ein, zwei Tagen beherrschen.« »Na ja, ich habe zwei Wochen gebraucht, bis ich gut damit zurechtkam. Aber Sie schaffen das gewiss schneller.« »MSX, was ist das? Das sagt mir im Moment nix.« »MSX ist ein Standard für Heimcomputer, der 1982 von mehreren japanischen und koreanischen Firmen ins Leben gerufen wurde, um die Hersteller von Heimcomputern unter einem technischen Standard zu vereinen. Das heißt, Drucker, Joysticks und Programme, die für einen MSX-Computer entwickelt wurden, können auch für alle anderen MSX-Computer verwendet werden. Firmen aus dieser MSX-Gruppe sind beispielsweise Sanyo, Sony, aber auch Philips, hier in Europa. Insbesondere von den Softwareherstellern, die nun ein Programm gleich für eine ganze Reihe von Heimcomputern entwickeln können, erwartet man in den nächsten Jahren sehr interessante Produkte. So gibt es inzwischen bereits Textverarbeitungssoftware, Karteikartensoftware und Ähnliches für diesen Rechner.« Ich hatte einen Käufer gefunden. Alles in allem war der Architekt davon überzeugt, dass ihm mein Rechner die Unterstützung liefern würde, die er sich erhoffte. Davon war ich ganz und gar nicht überzeugt. Aber ich wusste auch, dass die konkreten Wünsche, die er hatte, von keinem Rechner dieser Welt erfüllt werden konnten. Auch ein C64 oder IBM-PC, selbst ein Großrechner würde ihm da nicht viel helfen. Bei einem MSX-Rechner hatte er zumindest eine relativ einfache BASIC-Version, die zudem der BASIC-Version des zehnmal teureren IBMPC entsprach und auch von Microsoft war, sowie die Aussicht, dass asiatische Fir-

163

4.3

4


men reichlich Hard- und Software entwickeln würden. Auch die Erweiterbarkeit blieb nicht hinter dem C64 zurück (siehe Abbildung 4.12). Erst sehr viel später habe ich verstanden, dass es gerade diese völlig überzogenen Wünsche und Hoffnungen waren, ja die völlige Unkenntnis über die Art und Weise der Leistungen von Computern, die Hard- und Softwarehersteller immer wieder anspornte. Sie sorgte dafür, dass wir heute in unseren PCs Prozessoren haben, die jeden Superrechner von damals ganz alt aussehen lassen, und Software, mit der man Häuser in 3D entwerfen und virtuell begehen kann, und dass selbst Spielfilme wie Ice-Age oder Avartar am Computer entwickelt werden können. Ausschnitt aus dem Datenblatt des Spectravideo 318 Hersteller: Spectravideo Baujahr: 1983 Programmiersprache auf dem internen ROM: Microsoft Extended BASIC Prozessor: Zilog Z80 A Taktrate: 3.6 MHz RAM: 16 kB (aufrüstbar bis: 144 kB) ROM (mit Basic): 32 kB Graphic modes TMS9918A: 256 x 192 (16 colors), 40 x 24 characters (2 colors), 4 x 48 (16 colors) Colors 16 Soundbaustein: AY-3-8910 mit 3 Kanälen, 8 Oktaven Anschlussmöglichkeiten für: Fernseher (über Adapter), Monitor, Datenkassettentape, 2 Joysticks, eine Erweiterungs-Cartridge, den sogenannten Super Expander

Praxis: MSX-Rechner simulieren Natürlich kann man mit dem heutigen PC auch einen MSX-Rechner simulieren. Das entsprechende Programm gibt's im Internet unter http://www.bluemsx.com/, auf der DVD finden Sie den Emulator für Windows unter Software zum Buch\ Kap04\MSX\blueMSXv282full.exe. Nach der Installation erscheint ein Icon auf der Desktop-Oberfläche, mit dem das Programm gestartet werden kann. Über den Menüpunkt Run 폷 Start können Sie den Rechner in Betrieb nehmen. Ein kurzes Intro erscheint, und daraufhin erhält man auf einem blauen Display folgende Meldung: MSX BASIC version 2.1 (siehe Abbildung 4.13)

164


Abbildung 4.12

Erweiterungsmöglichkeiten für den SV 318

Abbildung 4.13

BlueMSX startet.

165

4.3

4


Im Gegensatz zu Windows hat der blaue Hintergrund keine negative Bedeutung. Man wollte nur eine eigene Farbnuance gegen das in der EDV vorherrschende Schwarz/Grün setzen (Terminalmonitore). Es ist sinnvoll, eine deutsche MSX-Maschine zu wählen, um die Sonderzeichen benutzen zu können: Tools 폷 Maschineneditor. Im Feld Konfiguration wählen Sie MSX2 – German aus und klicken auf die Schaltfläche Start. Dennoch ist es sinnvoll, sich das Tastaturlayout einblenden zu lassen oder es wenigstens einmal anzusehen. Das ist über den mittleren der drei unteren schwarzen Knöpfe am rechten Rand (siehe Abbildung 4.13) möglich. Der BASIC-Interpreter ist aktiv, und Sie können Ihren BASIC-Code direkt eingeben, beispielsweise so: 10 20 30 40 50 60 70 80 90 100 110 120 130

SCREEN2 P=3.1415926 LINE(66,10)-(189,50) CIRCLE(128,160), 60, , , ,20/60 FOR D=0 TO 2*P STEP 0.15 E=D+P/2 X=128+60*COS(D) Y=30+20*COS(D) S=128+60*COS(E) T=160+20*SIN(E) LINE(X,Y)-(S,T) NEXT D GOTO 130

An den Schluss wird eine Endlosschleife gesetzt, damit die gezeichnete Abbildung erhalten bleibt. Verglichen mit heutigen Grafikkarten und Grafikmodi war MSX nicht gerade leistungsfähig. Farben konnten im Screen2-Grafikmodus nicht für einzelne Pixel, sondern nur für Rechtecke der Größe 8 x 8 Pixel unterschiedlich gesetzt werden. Das sieht man sehr schön, wenn man die Linien des vorherigen Beispiels in verschiedenen Farben setzen möchte. 10 20 30 40 50 60 70 80 90 100

166

SCREEN2 P=3.1415926 LINE(66,10)-(189,50) CIRCLE(128,160), 60, , , ,20/60 FOR D=0 TO 2*P STEP 0.15 E=D+P/2 X=128+60*COS(D) Y=30+20*COS(D) S=128+60*COS(E) T=160+20*SIN(E)


105 110 120

C=INT(15*RND(1)) LINE(X,Y)-(S,T),C NEXT D

Natürlich sind die beiden Beispiele auch in der Dateisammlung der Buch-DVD enthalten. Sie finden diese unter Software zum Buch\Kap04\MSX. Um eine Datei zu laden, muss man zunächst eine virtuelle Diskette einbinden. Das kann ein Image oder ein Verzeichnis sein. Sie wählen es über folgenden Menüpunkt aus: File 폷 Diskettenlaufwerk B 폷 Directory einfügen, beispielsweise so: C:\temp\MSX. Dadurch wird das Verzeichnis unten in die Menüliste eingefügt.

Abbildung 4.14

Die MSX-Diskette (C:\temp\MSX) ist eingehängt und kann aktiviert werden.

Um die Diskette zu aktivieren, muss sie erst im Menü angeklickt werden. Neu aktivieren muss man sie ebenfalls, wenn man die Datei unter Windows editiert hat. Danach kann man eine Datei von dieser Diskette laden, z. B.: LOAD "b:mbasic01.txt"

Ob die Datei geladen wurde, lässt sich gut mit dem Befehl LIST prüfen, der die Programmzeilen anzeigt, die sich gerade im Hauptspeicher befinden. Bereits beim MSX-Rechner gab es eine ganze Reihe von Shortcuts, die die Bedienung wesentlich erleichterten. Auch der Emulator BlueMSX kennt solche Kurztasten, es gibt sogar einen Editor, um selbst Shortcuts zu definieren. Näheres dazu finden Sie auf den Hilfeseiten. 167

4.3


Eine gute MSX-Handbuchsammlung mit einer MSX-BASIC-Anleitung hält die Konami-Seite bereit: http://www.konamiman.com/msx/msx-e.html#msx2th. Wer die spielerischen Qualitäten eines MSX-Rechners noch kennenlernen möchte, findet auf der Buch-DVD zwei Spiele, die sich als Cartridge in den Rechner laden lassen: File 폷 Cartridge-Slot1 폷 Einfügen. Durch das Auswählen der gewünschten ROM-Datei wird die Cartridge sozusagen in den Rechner gesteckt. Die Steckplätze waren von oben zugänglich. Nach dem Aktivieren wird der Rechner neu gestartet und bootet von der Games-Cartridge. Neben Spielen gab es auch einiges an Anwendersoftware in Form von Cartridges zu kaufen. Man entfernt die Cartridge aus dem virtuellen Steckplatz, um das Spiel zu deaktivieren: File 폷 Cartridge-Slot1 폷 Auswurf. Der MSX-Standard hatte den Vorteil, dass er nach entsprechenden Erweiterungen ein echtes Betriebssystem unterstützte, nämlich CP/M. Leider hat er in Europa nie das Interesse erreicht, das ihm in Asien zuteil wurde. »Ich denke, da Kinder scheinbar die Welt in ihren Köpfen konstruieren müssen, um Menschen zu werden, müssen Menschen von Natur aus Konstrukteure sein.« »Computer sind das beste Konstruktionswerkzeug, das wir uns je haben einfallen lassen, außerhalb unseres Gehirns.« – Alan Kay

4.3.2

Der C64 – der König der Heimcomputer

Mit über zehn Millionen verkauften Exemplaren war der C64 der erfolgreichste Heimcomputer.

Quelle: http://de.academic.ru

4

Abbildung 4.15

168

Der Commodore C64 Homecomputer


Die Hardware war – wie bei Heimcomputern üblich – in einem etwas höheren Tastaturgehäuse untergebracht (scherzhaft Brotkasten getauft). Da war einmal der MOS 6510A von Motorola als 8-Bit-Prozessor und mit einem Custom Chip für die Grafik (VIC) und den Sound (SID), außerdem 64 KB RAM sowie etlichen Anschlussmöglichkeiten wie dem Monitorausgang und einem entsprechenden Monitor im Zubehörprogramm. Aber wie von jedem anderen Heimcomputer durfte man auch von diesem erwarten, dass er über den HF-Ausgang an den heimischen Fernseher angeschlossen werden konnte. Der C64 hatte ein 8-KB-ROM-BIOS, das seine Komponenten – Tastatur, serielle IEC-Schnittstelle für Diskettenlaufwerke und Drucker, Kassetteninterface und Videoausgabe – initialisierte und als Kanäle den Anwendungen und dem ebenfalls enthaltenen 8-KB-ROM-BASIC zur Verfügung stellte. Trotz der heute unvorstellbar geringen Ressourcen realisierte man erstaunliche Anwendungen, natürlich insbesondere im Bereich Spiele. Die ersten Computerspiele Erst mit den Homecomputern kam die große Lust am Computerspiel auf. Die Informatiker an den Großrechnern und den Minirechnern, wie dem PDP, hatten zwar vereinzelt so etwas wie Computerspiele entwickelt – Pong war beispielsweise eines dieser Spiele –, aber das waren teilweise nur Versuche im Rahmen von Forschungsaufträgen. Wenige Jahre später gab es Spielkonsolen, die in Gasthäusern und ersten Spielsalons aufgestellt wurden. Genau diese Spiele wollten die Homecomputer-Besitzer nun zu Hause spielen. Die Lust am Programmieren kam dazu, und die Zahl der Computerspiele explodierte regelrecht. Was mit den Heimcomputern begann, wurde ein Riesengeschäft.

Die Programmierung erforderte selbst mit der Sprache BASIC eine ganze Reihe Tricks und Kniffe, um brauchbare Ergebnisse zu erzielen. So entstand der Begriff des Spaghetticodes für verächtlich belächelten Programmierstil. Er war weniger, wie man vielleicht glauben könnte, das Ergebnis fehlender Programmierkenntnisse, sondern der Wunsch, Speicherplatz zu sparen – auch Formatierung kostet Bytes. Außerdem sollte der Quellcode unleserlich gemacht werden, insbesondere, weil Heimcomputer nur Interpreter besaßen, um selbstgeschriebene Programme auszuführen. Sie wurden als Quellcode weitergegeben und hatten keinerlei Schutzmöglichkeiten. Es bleibt zu erwähnen, dass die Verschlüsselung via Spaghetticode natürlich nicht sehr wirkungsvoll war.

169

4.3

4


Praxis I: Den C64 simulieren Viele der älteren Leser haben gewiss einmal einen C64 besessen und würden gerne noch einmal einen Blick zurückwerfen auf das leicht trübe Bild von damals. Andere waren damals vielleicht noch zu jung, um einen Homecomputer zu kaufen, oder möglicherweise noch gar nicht geboren. Für all diese Leser gibt es inzwischen die Möglichkeit, den C64 auf den modernen Flachbildschirm ihres Notebooks zu zaubern. Das Internet hält zahlreiche Emulationen des C64 bereit. Um nur eine Webseite zu nennen: http://www.c64games.de/phpseiten/emulatoren.php. Natürlich finden Sie auch auf der Buch-DVD entsprechende Programme: Software zum Buch\Kap04\C64\WinVICE-1.21. Der Emulator für den C64 heißt x64.exe. Achtung Beim Einsatz der Emulatoren kann es zu Störungen in der PC-Grafikdarstellung und der Soundausgabe kommen. Bei meinen Versuchen waren die Störungen zeitlich begrenzt und insgesamt zu verschmerzen.

Klicken Sie doppelt auf die Datei x64.exe, um die Emulation zu starten. Ein hellblauer Dialog wird geöffnet, der den blauen Dialog des C64 enthält. Er erinnert an den Dialog der MSX-Rechners, den wir bereits kennen (siehe Abbildung 4.13).

Abbildung 4.16

170

Der Commodore 64-Emulator in Aktion


Mit (Alt)+(¢) lässt sich zum Vollbild-Modus und wieder zurück schalten. Wenn wir schon bei den Tasten sind: (ª)+(Pos1) (nicht (Pos1) des Nummernblocks) löscht den Monitor, und jede Steuertaste, die innerhalb von Anführungszeichen gedrückt wird, wandelt der C64 in Sonderzeichen um, die genau das im Programm bewirken, was man mit den Steuertasten bei der Bedienung auslöst. Außerdem ist zu beachten, dass C64-BASIC üblicherweise nur Großbuchstaben nutzt. Die Hochstelltaste erzeugt bei verschiedenen Tasten Sonderzeichen, die im Programm Fehler verursachen. Versuchen wir es zunächst einmal ganz einfach: PRINT "More Coding for Fun!"

Nach dem Drücken der (¢)-Taste wird die Zeile sofort interpretiert und ausgeführt. Der Dialog sollte nun in etwa so aussehen wie in Abbildung 4.16. Das soll uns fürs Erste einmal genügen. Mehr dazu gibt es im Praxisteil III. Die Firma »Commodore« Der Name der Firma war eigentlich Commodore Business Machines International (CBM). Sie wurde 1954 vom polnischstämmigen Amerikaner Jack Tramiel5 (eigentlich: Idek Tramielski) in Toronto, Kanada gegründet. Nach seiner Befreiung durch die Amerikaner aus dem KZ lernte er bei der US Army so etwas wie Büromaschinenmechaniker. Nachdem er 1952 aus der Army ausgetreten war, arbeitete er in diesem Beruf weiter und eröffnete einen entsprechenden Laden in der Bronx. Er reparierte in der Hauptsache Schreibmaschinen, als er die CBM in Kanada gründete, weil dies wirtschaftlich interessanter war. 1962 ging er bereits an die Börse. Ab den 70er Jahren stellte CBM Taschenrechner her und war schließlich durch die Übernahme der Firma MOS Technologies, einem Prozessorhersteller, in der Lage, erste Mikrocomputer herzustellen. Das war zunächst 1977 der PET 20016, der VC20 und schließlich der C64. Der PET 2001 bestand aus einer Tastatur, die mehr an einen Tischrechner oder eine Kaufhauskasse erinnerte als an eine Schreibmaschinentastatur, einem integrierten Rekorder und einem fest aufsitzenden Monitor, was ihm viel Kritik zur schlechten Ergonomie einbrachte. Trotzdem war er der erste Rechner, der weltweit im normalen Handel für jedermann erhältlich war. In Deutschland kostete er bei Quelle 2.999,– DM. Er war auch der erste Rechner, der die Aufschrift »Personal Computer« trug. Mit dem PET deutete sich schon vor der eigentlichen Zeit des Heimcomputers an, dass sich der Elektronenrechner aufmachte, zu einem Alltagsgegenstand zu werden. Auch vom PET gibt es einen Emulator, der sich auf der Buch-DVD befindet: Software zum Buch\Kap04\C64\WinVice-1.21\xpet.exe. 5 Idek Tramielski erblickte am 13. Dezember 1928 in ód das Licht der Welt. 6 PET steht für Personal Electronic Transactor.

171

4.3


© Tomislav Medak; www.google.de

4

Abbildung 4.17

Der PET 2001

Am 13. Januar 1984 verließ Tramiel die Firma CBM, weil er sich mit dem Hauptinvestor Irving Gould überworfen hatte. Die verdienten Millionen versetzten ihn in die Lage, die Firma ATARI Inc. zu kaufen, die zwar erst 1972 gegründet worden war, sich jedoch bald zum führenden Anbieter von Spielhallenkonsolen entwickelt hatte. Tramiel richtete die Produktpalette in Richtung hochwertige Heimcomputer aus. Die eingefleischte Fangemeinde dieser ST genannten Computerreihe war jedoch nicht groß genug, um den Commodore-Amgia-Freunden Paroli zu bieten. Trotz zahlreicher Anwendungen im Bereich Musikszene und Desktop-Publishing blieben die Absatzzahlen zu klein, um den Bestand der Firma auf Dauer zu sichern. Am 30. Juli 1996 wurde Atari vom Festplattenhersteller JTS Corp. übernommen. Am 29. April 1994 ging Commodore in Konkurs. Der Markenname wird allerdings noch bis heute genutzt. Tramiel, der Atari bereits mit seinen Söhnen gemeinsam geführt hatte, zog sich endgültig aus dem Computergeschäft zurück. Fragte man Jack Tramiel, wie er auf den Namen Commodore für seine erste Firma gekommen war, erzählte er immer folgende Geschichte: »Ich war in Sachen Schreibmaschinen in Berlin unterwegs. Es war die erste Zeit des Wirtschaftsaufschwungs und mich beeindruckten vor allem die großen Autos, die zwar noch selten vorbeifuhren, aber deshalb nicht weniger Eindruck machten. Hier gab es den Opel Admiral, den Kapitän und so weiter.

172


Aber ich wollte einen amerikanischen Rang, da fuhr ein Hudson Commodore vorbei, der in Detroit ab 1941 gebaut wurde. Und ein Commodore ist bei der Army so was wie ein Admiral. Nun wusste ich, meine Firma würde Commodore heißen.« 1976 hatte CBM finanzielle Probleme, schaffte es aber trotzdem, die Firma MOS Technologies zu übernehmen, die später die Prozessoren für Tramiels Rechner liefern konnte. Im selben Jahr wollte er eine weitere Firma kaufen, diese hieß Apple. Man wurde sich nicht einig, Tramiel bot Jobs angeblich 20.000 $ zu wenig. Die Computergeschichte wäre ganz anders verlaufen, hätte Tramiel nicht so knallhart verhandelt ... Praxis II: C64-Spiele simulieren Wie das damals alles war, kann man sich heute mit Hilfe des C64-Simulators ansehen. Mit der C64-Emulation kann man nicht nur programmieren, sondern auch die alten Spiele noch einmal spielen. Eine Liste der C64-Spiele gibt es bei Wikipedia: http://de.wikipedia.org/wiki/Liste_bekannter_C64-Spiele. Viele der alten Spiele findet man auf C64-Seiten im Internet. Die bekanntesten Spiele für den C64 waren in Deutschland: 왘

Pac Man, der absolute Klassiker, ein Geschicklichkeitsspiel von Atarisoft/ Namco aus dem Jahre 1983

왘

Defender of the Crown, Strategiespiel und Amigaklassiker von Cinemaware aus dem Jahre 1987

왘

Maniac Mansion, erschien 1987 als Point-and-Click-Adventure aus der Softwareschmiede Lucasfilm Games

왘

Summer-/Winter-/Worldgames, eine Sportsimulation von Epyx, 1984

왘

Pinball Construction Set, als Game-Builder speziell für Flipperspiele von Electronic Arts aus dem Jahre 1983

왘

Hanse, eine Wirtschaftssimulation von Ariolasoft aus dem Jahre 1986

Natürlich ist das nur eine recht kleine, aber deshalb leider auch willkürliche Auswahl. Hat man ein solches Spiel aus dem Internet bezogen und entpackt, lässt es sich per Menü in den Rechner laden. Die Menüpunkte sind: File 폷 Autostart disk/ tape image.

173

4.3

4


In Suchen in: wählen Sie das Verzeichnis aus, in dem die Spiele-Datei liegt, und klicken sie an. Mit Attach wird sie geladen.

Abbildung 4.18

Die Datei mit dem C64 laden

Nachdem das Spiel geladen ist, muss die entsprechende Steuerung aktiviert werden. Die meisten Spiele werden mit Joystick gespielt – nun heißt es also, die Joystick-Steuerung einzurichten. Das gelingt über die Menüpunkte Settings 폷 Joystick settings...

Abbildung 4.19

174

Die Tasten als Joystick-Ersatz einrichten


Natürlich lassen sich auch PC-Joysticks nutzen. Falls Sie keinen Joystick besitzen, wählen Sie im Dialogfenster oben ein Keyset aus und konfigurieren es mit den Schaltflächen oberhalb von OK (siehe Abbildung 4.19). Nach Anwahl einer Schaltfläche für die Richtung, z. B. South, drücken Sie die entsprechende Taste auf der Tastatur, und schon ist die Verwendung als Joystick-Taste festgelegt. Danach steht dem Spielerlebnis aus Heimcomputer-Tagen nichts mehr im Wege. Viele der Spiele sind leider reine Ballerspiele von nicht gerade überwältigendem Niveau. Es gibt aber auch zahlreiche anspruchsvolle Spiele, wie z. B. Pirates oder Der Ring der Nibelungen.

Abbildung 4.20

Der Ring der Nibelungen

Emulationsprogramme für andere Homecomputer Wir haben nun beispielhaft zwei Homecomputer besprochen. Natürlich gibt es viele weitere Geräte, die alle ihre genialen Features hatten und ihre Verehrer gefunden haben. Zu den meisten Maschinen gibt es inzwischen auch sehr gute Emulationsprogramme, mit denen man die Rechner von damals auf dem PC nachempfinden kann. Das Internet bietet die entsprechenden Webseiten dazu. Wer sich näher damit befassen möchte, wird mit Sicherheit sehr schnell fündig werden. Beispielhaft sei hier nur eine Seite erwähnt: http://www.emulatorzone.com/. Für einige dieser Emulatoren ist jedoch die Original-ROM-Software erforderlich, die meist strengen Copyright-Rechten unterliegt. Praxis III: Den C64 in BASIC programmieren Das interne BASIC des C64 ist direkt nach dem Start verfügbar. Gibt man beispielsweise PRINT "More Coding for Fun"

175

4.3

4


ein, wird der Text wie gewünscht einmal ausgegeben. Aber damit geben wir uns als angehende BASIC-Fachleute nicht zufrieden. Bei der Programmierung des C64 ist einiges zu beachten. Weil der Sprachumfang des internen BASIC nicht gerade gewaltig ist, wird vieles über Programmiertricks erreicht. Etliche professionelle Programme wurden gleich in Assembler realisiert, um schnell genug ausgeführt werden zu können. Außerdem sind die wahren Möglichkeiten des kleinen Rechners nur in Assembler wirklich auszureizen. Sollten Schwierigkeiten bei den Zeichensätzen auftreten, so dass die gedrückten Tasten nicht die gewünschten Zeichen bringen, kann das an Einstellungen des Emulators liegen. Mit Settings 폷 Joystick settings... können die Tasten mit Joystick-Befehlen belegt werden, die bewirken, dass andere Zeichen angezeigt werden als bei den Tasten üblich. Insbesondere die Cursortasten sind so vorbelegt, dass man die Joystick-Vorbelegung erst abschalten sollte, bevor man mit dem Programmieren beginnt: Settings 폷 Joystick settings..., Joystick in port #1 und Joystick in port #2 auf None einstellen. Jetzt können wir beginnen, wobei wir Folgendes beachten müssen: Gibt man eine Zeile ohne Zeilennummer ein, wird sie nach dem (¢) direkt ausgeführt. Eine Zeilennummer sorgt dafür, dass die Zeile im Programmspeicher landet und erst ausgeführt wird, nachdem der Befehl RUN eingegeben wurde. Mit der (Esc)Taste kann das laufende Programm unterbrochen werden. Groß- oder Kleinschreibung ist beim Programmcode unerheblich, deshalb wird üblicherweise alles großgeschrieben. Steuerzeichen, also Funktionen, die man über eine Taste aufrufen kann, z. B. (½), können innerhalb von Anführungsstrichen genutzt werden. Invers7 dargestellt, werden sie im Programm wie Tastenklicks ausgeführt. Mit LIST lässt sich ein Programm auflisten, über den Menüpunkt Snapshot 폷 save Snapshot image... kann es mit dem gesamten Speicher gesichert werden. Ein echter C64 speichert natürlich auf seiner Datasette, sprich auf dem Kassettenrekorder. Das hat etwas von den Bändern der Großrechner. Programme werden sequenziell hintereinander auf dem Band abgelegt. Identifizieren kann man sie durch ihren Namen, den man hinter dem Befehl SAVE angibt. Tippt man beispielsweise SAVE »VERSUCH« ein, so meldet der C64: PRESS RECORD & PLAY ON TAPE Über File 폷 Attach Tape Image... kann man einen Namen für die Datei angeben, die das Kassettenband darstellt. Sie erhält die Endung .tap. Über die Schaltfläche Create Image kann man sie anlegen. Mit Attach wird sie angehängt. Nun lässt sich über File 폷 Datasette control 폷 Record das Programm auf Band ablegen. Es dauert etwas, bis die Speicherung durchgeführt ist (genau wie im richtigen Leben).

7 Dunkel auf hellem Grund statt hell auf dunklem Grund.

176


Lesen lässt sich so eine Datei vom Band über den Befehl LOAD gegebenenfalls mit dem Programmnamen dahinter, ansonsten liest der Rechner das, was er als Nächstes auf dem Band findet. Danach sollte man den Start des Bandes nicht vergessen: File 폷 Datasette control 폷 Start. Rechts unter dem blauen Monitor können Sie an der Tapecontroll erkennen, in welche Richtung gerade gespult wird, ein Bandzählwerk zeigt die Stellung des Bandes an. Doch nun zum Programm. Wie wäre es mit diesem Code: 10 REM LAUFSCHRIFT 20 PRINT " " 30 FOR P = 0 TO 20 40 PRINT " " 50 FOR BA = 0 TO 30 60 PRINT " MORE CODING FOR FUN 70 FOR Z = 1 TO 100 80 NEXT Z 90 NEXT BA 100 PRINT " "; 110 NEXT P 120 GOTO 20

";

Die verwendeten Steuersequenzen befinden sich jeweils hinter einem ": (ª)+(Pos1) (½) (æ)

Genaueres zu den Zeichensätzen finden Sie unter: http://www.c64-wiki.de/ index.php/Zeichen. Erläuterungen: Zunächst wird per Steuerzeichen der Bildschirm entleert. Jetzt kommt eine zählende Schleife von 0 bis 20. Das nächste Steuerzeichen geht eine Zeile nach unten. Nun folgen die Schritte des Textes – mit Hilfe der zählenden Schleife – bis 30. PRINT " MORE CODING FOR FUN

";

Das Semikolon am Zeilenende von PRINT bewirkt, dass das nächste PRINT noch einmal in die gleiche Zeile geschrieben wird.

177

4.3

4


Die nächste zählende Schleife dient als Bremse, damit das Ganze nicht zu rasch abläuft. Wenn man alles eingetippt hat, startet man mit dem Befehl RUN . Nun beginnt das Programm, vorausgesetzt man hat keinen Fehler gemacht, endlos durchzulaufen (siehe Abbildung 4.21). Mit einem Druck auf die (Esc)-Taste kann man es jedoch jederzeit unterbrechen. Hat man einen Fehler in einer Zeile entdeckt, so gibt man die Zeile einfach wieder neu ein. Der C64 ersetzt sie im Programmspeicher durch die neue Zeile.

Abbildung 4.21

More Fun mit dem C64

Der Code des Programms befindet sich natürlich auch auf der DVD: als Snapshot in Software zum Buch\Kap04\C64\Programm\fun.vsf, als Kassette in Software zum Buch\Kap04\C64\Programm\fun.tap. Eine Datei wie WinVICE-1.21 sollte man zuvor auf die Festplatte kopieren. Die Snapshot/Tap-Datei kann man im Verzeichnis WinVICE-1.21\C64\ ablegen. In den Speicher des C64 bekommt man sie über Snapshot 폷 Load quicksnapshot image. Wie kann man das Programm abändern, um zu erreichen, dass die Schrift ununterbrochen durchläuft? Die Lösung befindet sich auf der Buch-DVD als Snapshot in Software zum Buch\ Kap04\C64\Programm\fun2.vsf, als Kassette in Software zum Buch\Kap04\C64\ Programm\fun2.tap.

178

Der IBM-PC: besser spät als nie

Leider haben wir damit noch lange kein Spiel wie Boulderdash für den C64 programmiert. Wir konnten jedoch etwas von dem Spaß erahnen, den es gemacht haben muss, den Brotkasten »zum Leben zu erwecken«.

Abbildung 4.22

Boulderdash

Wer jedoch das Thema weiter vertiefen möchte, findet sehr umfangreiche und gute Seiten zum Thema C64 im Internet. »Es ist ziemlich unfair, von einer frisch aus der Fabrik kommenden Maschine zu erwarten, dass sie mit einem Akademiker konkurrieren könne.« – Alan Turing

4.4

Der IBM-PC: besser spät als nie

Als IBM seinen PC präsentierte, war die Fachwelt bereits der Meinung, der Gigant habe den Anschluss verpasst, er würde niemals mit einem Mikrorechner auf den Markt kommen und stattdessen lieber weiter Großrechner bauen. Man sollte sich täuschen. Das Geniale am IBM-PC war seine Erweiterbarkeit mit Hilfe von Steckkarten. Die hatte es auch schon bei Vorgängermodellen gegeben, wie beispielsweise dem Apple II (siehe Abbildung 4.23) mit seinen acht Steckplätzen. Der PC besaß zwar in seiner ersten Ausführung nur fünf Steckplätze, hatte aber einen Vorteil, den der Apple-Rechner nicht hatte: Der Rechner war aus genormten Standardbautei-

179

4.4


len aufgebaut und hatte genau definierte Schnittstellen, so dass jede Firma für die vorhandenen Steckplätze Karten herstellen konnte.

Quelle: www.allaboutapple.com

4

Abbildung 4.23

Apple II geöffnet

Allerdings stellte sich bald heraus, dass es nicht nur möglich war, Steckkarten für diesen Rechner herzustellen. Wenn man wollte, konnte man gleich den ganzen Rechner nachbauen. Insbesondere die jungen Elektronikfirmen in Asien erkannten ihre Chancen. Es gab bald Nachbauten aus Japan, Taiwan und Hongkong. Von IBM wurden die Rechner einfach mit IBM PC-convertible bezeichnet. In Europa nannte man sie PC-Kompatible oder PC-Clone. Das Einzige, was von IBM nicht freigegeben wurde, war das sogenannte BIOS, das auf einem SRAM-Baustein8 abgespeichert ist und zum Starten für die Konfiguration und die Ansteuerung der Hardware vom Betriebssystem dient. Doch auch hier kamen Fremdhersteller dazu. Da zahlreichen PC-Clone-Produzenten BIOS-Programme benötigten, spezialisierten sich Softwarefirmen auf diese hardwarenahe Software und lieferten im Auftrag oder für ganze Baureihen spezielle BIOS-Versionen. 8 Anfangs wurden sie oft als CMOS-Bausteine bezeichnet, obwohl das eine allgemeine Bezeichnung für viele verschiedene IC s einer bestimmten Herstellungsart ist. Viele Prozessoren, Speicherbausteine und Sensorelemente sind CMOS-Bausteine.

180

Noch mehr Spaß: Atari, Amiga und Co.

Die bekanntesten BIOS-Hersteller waren: 왘

AWARD

왘

Phoenix

왘

A.M.I.

Das BIOS eines Rechners war nicht selten Grund für Probleme. Eine Webseite, die sich intensiv mit dem Thema BIOS auseinandersetzt, findet man unter http:// www.bios-info.de/. Eine HTML-Version des sogenannten BIOS-Kompendiums findet man auf der DVD unter \Bios-Kompendium\bioshtm.zip. Die PC-Nachbauten waren oft wesentlich billiger als das Original von IBM und trugen einen Großteil zu der immensen Verbreitung des Rechnermodells bei. Der Aufbau des Apple II war dagegen lange Verschlusssache, und so gab es auch kaum Nachbauten – und der PC verdrängte den Apple II vom Markt. Die PC-Clone dagegen eroberten erst die Büros in den Firmen und Zuhause und später Kinder- und Wohnzimmer. Heute ist im Grunde jeder PC – ob kleines Netbook oder hochgezüchtete Workstation – nur eine Weiterentwicklung des ersten IBM-PCs. Sie haben, wie kaum ein technisches Gerät vorher, unsere Welt mitgestaltet und verändert.

4.5


Bevor wir uns im nächsten Kapitel mit den modernen Rechnern befassen, wollen wir noch einmal einen Blick zurückwerfen auf dessen »Vorfahren« und andere Verwandte. Hier wäre zunächst einmal die von Jack Tramiel aus der Taufe gehobene Atari ST-Serie zu erwähnen. Sie hatte als erste Homecomputer von Haus aus eine grafische Oberfläche. Es war GEM unter dem Betriebssystem TOS. Beides war sehr eng miteinander verzahnt, so dass man zur Bedienung nicht unbedingt auf die Textoberfläche wechseln musste. Die Atari ST-Reihe besaß eine MIDI-Schnittstelle, daher war sie in der professionellen Musikproduktion sehr beliebt. Unter anderem hat Mike Oldfield einen Atari 1040ST mit dem Programm »C-LAB Notator« für einige seiner Songs genutzt. Der Atari-Monitor SM124 hatte für die damalige Zeit eine sehr gute Auflösung, daher konnte sich diese Rechnerreihe auch im Layout und Designbereich etablieren.

181

4.5

4


Interessant war ebenfalls, dass die Diskettenformate dem DOS-Format nahekamen und man den Atari so zur Übertragung von Dateien nutzen konnte. Zahlreiche Emulatoren, wie ein Apple-Emulator, ein Z80- und ein CP/M-Emulator, nutzten diese Hardwareeigenschaft aus, und so wurde er auch als Terminalersatz bei Großrechnern und Minicomputern verwendet.

Abbildung 4.24

Die Steem-Atari ST-Simulation

Einen Emulator finden Sie im Netz unter http://www.bunkahle.com/Aktuelles/ AtariST.html und http://www.aep-emu.de/emus11.html sowie auf der Buch-DVD im Verzeichnis Software zum Buch\Kap04\Atari. Commodore brachte als Antwort auf die erfolgreichen Atari ST-Modelle den Amiga 1000. Dieser wurde nicht etwa selbst entwickelt, sondern man übernahm die Herstellerfirma in einer Art Übernahmekrimi. Denn die Firma Amiga Corp. war von Jay Miner 1981 unter dem Namen Hi Toro gegründet worden, nachdem er Atari verlassen hatte. Ursprünglich wollte er nur eine neue Spielkonsole entwickeln. Mit der Zeit wurde daraus jedoch das Konzept zu einem sehr leistungsstarken Computer. Atari gehörte damals zu Warner Communications, die auch die »externe« Entwicklung des Amiga bezahlte, um damit den überholten Atari XL abzulösen. Warner Communications trennte sich von Atari, das Jack Tramiel am 2. Juli 1984 kaufte, nachdem er Commodore verlassen hatte. Damit war allerdings nicht die Firma Amiga Corp. verbunden, die Tramiel natürlich gerne auch übernommen hätte. Er bot den Aktionären 0,98 $ pro Anteilsschein. Irving Gould, der Chef von Commodore, bot kurz vor Auslaufen der Bieterfrist 4,25 $ und bekam natürlich Amiga. Aber das Angebot war so großzügig bemessen, dass Commodore sich dabei fast finanziell ruinierte. 182


Der Amiga allerdings wurde ein finanzieller Erfolg und eine Computerlegende. Im Handel war er ab dem 23. Juli 1985 bis 1996, als ESCOM das letzte AmigaModell herausbrachte, den Amiga A4000T. Das Wegweisende an diesem Rechner war seine enorme Leistungsfähigkeit: Sein Betriebssystem war multitaskingfähig und ähnelte damit UNIX oder Linux, und er besaß multimediale Fähigkeiten, die zum großen Teil auf den sogenannten Custom Chips beruhten. Diese kann man sich als eine Art Coprozessoren denken, die auf die jeweilige Aufgabe spezialisiert waren. Diese Chips hatten fast alle weibliche Namen als Bezeichnung. So, wie Amiga Spanisch ist und »Freundin« heißt, gab es auch noch Paula: den Soundchip, der außerdem für die Interruptsteuerung zuständig ist und den Diskettenkontroller darstellt

왘

Denise: den Grafikkontrollchip

왘

Agnus: einen Tausendsassa wie Paula, DMA-Konroller, Timer und Blitter9, aber auch Grafikcoprozessor.

© Kaiiv; http://de.wikipedia.org

왘

Abbildung 4.25

Commodore Amiga A1000

9 Dabei handelt es sich um einen Grafikbeschleuniger, er kopiert und verschiebt ganze Bildbereiche.

183

4.5


Es gibt sehr wohl einige AMIGA-Emulatoren, die man sich auch legal und kostenlos im Internet downloaden kann. Allerdings benötigt man für ihren Betrieb in jedem Fall das sogenannte Kickstart-ROM, also das Original-ROM des AMIGA. Dieses ist urheberrechtlich geschützt und kann deshalb auch nicht auf der BuchDVD beigelegt werden. Wer einen AMIGA besitzt, kann den Inhalt des ROMs per Software in einem Image ablegen und damit einen Emulator betreiben. Aber wer einen Amiga hat, braucht auch keinen Emulator zu verwenden. Außerdem gibt es die Möglichkeit, ROM-Versionen zu kaufen. Ein weiterer sehr beachtlicher Homecomputer war der Acorn Archimedes (siehe Abbildung 4.27). Mit ihm hielt die RISC-Technologie Einzug in den Homecomputer-Markt. RISC steht für Reduced Instruction Set Computer. Im Gegensatz zum CISC-Prozessor versteht man darunter einen Prozessor, der einen kleinen Satz einfacher Befehle hat, die jedoch enorm rasch ausgeführt werden können. Der Acorn Archimedes war daher damals achtmal schneller als ein Amiga und zehnmal so schnell wie ein IBM-PC. Entwickelt wurde er von der englischen Firma Acorn, die ursprünglich CPU hieß und von Hermann Hauser und Chris Curry, einem ehemaligen Mitarbeiter von Clive Sinclair, 1978 gegründet worden war. Sinclair baute 1980 den damals billigsten Heimcomputer, den ZX80 (siehe Abbildung 4.26). Acorn stand erst in direkter Konkurrenz zur Firma Sinclair, bis sie ihren eigenen Prozessor entwickelten. Aus Enttäuschung über die Leistungsschwächen der erhältlichen Prozessoren entwickelte man einen eigenen Prozessor nach dem neuartigen RISC-Prinzip und landete damit einen Volltreffer.

Quelle: http://ksv.bytemap.de

4

Abbildung 4.26

184

Der Sinclair ZX80

Lesen Sie weiter

Quelle: http://old-school-micro.blogspot.com

Und er wird in verbesserter Form bis heute gebaut. Denn Acorn gründete 1990 mit Apple zusammen die Firma ARM Limited, die noch heute Prozessoren für verschiedene Handys und Kleincomputer lizenziert und liefert. Auch zu AcornRechnern gibt es Emulatoren für den PC: http://b-em.bbcmicro.com/arculator/ download.html. Für diesen Emulator benötigt man ebenfalls die ROMs der Originalmaschine.

Abbildung 4.27

Der Acorn Archimedes A3020

Mit all diesen Programmen ist es leicht möglich, eine Zeitreise in die Welt der Heimcomputer zu unternehmen. Wer dagegen sehen möchte, wie so ein Emulator aufgebaut ist, kann sich den folgenden ansehen, einen sehr interessanten Emulator für den C64: den jsc64 von Tim de Koning. Er ist Freeware und ganz in JavaScript geschrieben, so dass man sich relativ leicht in dem Code zurechtfindet. Der Sourcecode liegt im Netz unter http://github.com/Kingsquare/jsc64. »Computer sind eigentlich nicht sonderlich beliebt, weil sie viel Ärger machen. Dabei können wir froh sein, dass sie sich nicht wirklich wehren können.« – Anonymus

4.6

Lesen Sie weiter


Beschreibung

http://simh.trailing-edge.com/

Computer-history-Simulations-Projekt

http://simh.trailing-edge.com/links.html

Überblick über Simulatoren

185

4.6

4


URL

Beschreibung

http://simh.trailing-edge.com/ software.html

Software für den Simh-Simulator

http://simh.trailing-edge.com/pdf/ all_docs.html

Simh-Dokumentation

http://www.mcmanis.com/chuck/ computers/vaxen/

VAX-Seite in Englisch

http://www.openvmshobbyist.com/ news.php

Open VMS

http://www.scribd.com/doc/19157112/ Handbuch-C128

Handbuch des C128

ftp://ftp.netbsd.org/pub/NetBSD/iso/5.0.2/ FTP-Seite: NetBSD für alle denkbaren Rechner ftp://iso.de.netbsd.org/pub/NetBSD/iso/

NetBSD für alle denkbaren Rechner

http://www.msx.d4e.co.jp/1chipmsx.html

1 Chip MSX-Rechner (japanisch)

http://www.sueddeutsche.de/wirtschaft/ 497/346335/text/

Artikel vom 6.2.2007 über die Beilegung des Apple/Apple-Markennamensstreits

http://pom1.sourceforge.net/

Seite zum POM1-Emulator

ftp://public.asimov.net/pub/apple_II/ documentation/

riesiges Archiv mit Apple-Emulatoren und Apple-Software

http://www.mr-gadget.de/tech-history/ 2008-12-08/vor-40-jahren-praesentiertedoug-engelbart-die-erste-computermaus/

Geschichte der Computermaus

http://de.sevenload.com/videos/ n593w7S-Apple-und-Xerox

Kurzfilm zur Vorführung des Xerox Alto im November 1979

http://www.digibarn.com/collections/ software/alto/index.html

Homepage zum Xeros Alto

http://www.basic.msxall.com/

MSX-Seite mit Programmen

http://www.lexlechz.at/de/msx.html

private MSX-Seite

http://fms.komkon.org/MSX/

ausführliche MSX-Dokumentation

http://www.samdal.com/spectravideo.htm

Spectravideo-Fanseite

http://www.atarimagazines.com/creative/ Beitrag zur MSX-Grafik v10n2/204_Simple_screen_graphics_wi.php http://members.chello.nl/r.wiersma19/ index.html#games

MSX-Spiele

http://www.konamiman.com/msx/ msx-e.html#msx2th

MSX-Handbücher

186

Lesen Sie weiter

URL

Beschreibung

http://www.emulator-zone.com/

Emulator-Seite mit zahlreichen Links

http://www.kingsquare.nl/jsc64

ein C64-Emulator in JavaScript

http://www.homecomputermuseum.de/ doku/man_de.htm

Commodore-BASIC-Handbuch

http://cbm.6502.org/alternative/c64_de/ c64_de.pdf

C64-Handbuch

http://www.server3-amiga-island.de/html/ c64_spiele_von_a.html

sehr umfangreiche C64-Spieleseite

http://www.zock.com/64er/8404/ 0017.html

C64-Zeitschrift

Literatur zum Kapitel Wozniak, Steve et al.: iWoz: Wie ich den Personal Computer erfand und Apple mitbegründete. Hanser Wirtschaft 2006.

187

4.6

Die Entwicklung der Computer hat bis heute keine Pause eingelegt. Das Mooresche Gesetz hat sich erstaunlicherweise bis heute bewahrheitet. Es besagt, dass sich die Leistung der Rechner etwa alle zwei Jahre verdoppelt – ein binärer Zusammenhang, der nicht weniger besagt, als dass sich die Leistung in zehn Jahren ver32facht. So ist es nicht verwunderlich, dass heutige Standardrechner vor zehn Jahren noch als Supercomputer bezeichnet worden wären. Ganz zu schweigen von der Zeit, als IBM seine 370er auslieh oder Konrad Zuse den ersten Rechner baute. Somit hat der Durchschnittsdeutsche aus Sicht der Computerpioniere einen Supercomputer im Wohnzimmer stehen. Ich möchte daher unsere aktuellen Rechner unter der Überschrift »Superrechner« besprechen.

5

Der Superrechner im Wohnzimmer

2000

Nov. 2000

2001

2005 2006

2010

1 GHz PC Pentium 4 64 Bit PCs Dualcore Virtualisierung iPad

5.1

Der PC erobert die Welt

Die erste Firma, die überhaupt einen PC-Clone anbot, war die Firma Compaq. Das war im März 1983. Zudem war der Rechner tragbar, wenn auch in einer uns heute nicht mehr geläufigen kofferartigen Form, und so billig, dass er kaum mehr 189


als der Original-PC kostete. Je nach Ausstattung musste man für den Compaq 3.500 $ und für den PC 3.000 $ auf den Tisch legen. Weil der Compaq trotz seiner 20 kg mit Hilfe eines Koffergriffs bequem zu tragen war, fand er seine Liebhaber insbesondere im Berufsfeld der Vertreter und Makler und bei Anwendern, die nicht extra einen Schreibtisch für das Gerät aufstellen wollten.


5

Abbildung 5.1

Der Compaq Nr. 1 – ein Kofferrechner

Die Firma Compaq war ein Jahr zuvor von ehemaligen Mitarbeitern der Texas Instruments – der Firma, die 1958 den ersten integrierten Schaltkreis entwickelt hatte – gegründet worden. Sie hießen Bill Murto, Joseph R. Canion und Jim Harris. Sie trafen sich nach der Arbeit in einem Café in der Nähe der TI-Niederlassung in Houston, der zweitgrößten in den USA. Hier konnten sie in Ruhe noch ein wenig fachsimpeln. Und hier haben sie die Idee vom eigenen Rechner entwickelt. Es sollte ein IBM-PC sein; dieses Rechnermodell war gefragt und bestand aus Standardbausteinen, so dass ihn im Grunde jeder nachbauen konnte. Was fehlte, war ein DOS, das originale PC-DOS konnte man nicht nehmen. Aber Microsoft hatte im Vertrag mit IBM festgelegt, dass es sein DOS auch anderen Rechnerherstellern anbieten durfte, und zwar unter dem Namen MS-DOS. Fehlte nur noch das BIOS, die in einen ROM-Baustein gebrannte Softwareschnittstelle zwischen dem Betriebssystem und der Hardware. Dieses kleine Stück Software musste man neu programmieren, und es sollte sie am Ende über eine Million Dollar kosten. Nun ging es nur noch um die Form. Joseph R. Canion, genannt Rod, breitete seine Serviette auf dem Tisch aus. Man war sich schnell einig darüber, dass der Rechner, wenn es schon ein Nachbau

190

Der PC erobert die Welt

sein sollte, einzigartig werden musste. »Wie wäre es mit einem tragbaren Gehäuse?« Es wurden ein paar Entwürfe aufgekritzelt. Um tragbar zu sein, musste das Gehäuse stabiler werden als am Original, ein kleiner Knuff durfte nicht gleich eine Beule hinterlassen. Damit er nicht zu schwer wurde, sollte mehr Plastik verwendet werden als am Original. Das stabile Gehäuse und die solide Verarbeitung sollte ein Markenzeichen für Compaq werden, auch bei den Tischgeräten. Die Serviette bekam schließlich die Unterschrift und der Beschluss eine Firma zu gründen, um einen tragbaren PC zu bauen, standfest. Compaq erwies sich 1987 als federführend bei der Verwendung des 80386Mikroprozessors und baute seine Marktstellung gewaltig aus, als man den Markt des Privatanwenders mit der PC-Reihe Presario im Preissegment um die 1.000 $ belieferte. Um den Preis niedrig zu halten, setzte man als einer der ersten Hersteller auch Prozessoren von Cyrix und AMD ein und verhalf diesen Firmen so zum Markterfolg. Auch an Expansionsplänen sollte es nicht fehlen. Man übernahm 1997 die Firma Tandem Computers, einen Spezialisten für ausfallsichere Rechner, und schließlich 1998 die legendäre Digital Equipment Corp., die die mittlere Datentechnik mit dem PDP erfand und mit ihren VAX-Rechnern Computerlegenden schuf. Doch die Folgen der Übernahmen kamen Compaq teuer zu stehen. Die Firmen waren zu verschieden, als dass man sie problemlos hätte zusammenschweißen können. Man begann, Marktanteile zu verlieren. Da passierte das Unerwartete: Carly Fiorina, die Chefin von Hewlett Packard, kurz HP genannt, fasste den Entschluss, Compaq zu übernehmen. Sie war damals die einzige Frau, die es in der Computerindustrie bis ganz nach oben geschafft hatte, und eine eiskalte Managerin. HP verdiente sein Geld seinerzeit hauptsächlich mit Druckern und anderer Peripherie. Fiorina hatte angekündigt, aus HP wieder einen der ganz großen Global Player in der Computerwelt zu machen. Dazu kamen ihr die finanziellen Probleme von Compaq gerade recht. Von den Ingenieuren als branchenfremd verschrien, begann sie die Übernahme-Verhandlungen mit Michael Capellas, dem damaligen Chef von Compaq. Der Markt nahm ihre Idee nicht gut auf und die Kurse beider Firmen brachen ein. Walter Hewlett, der Sohn eines der Firmengründer, die HP damals tatsächlich in einer richtigen Garage als erste Firma von Silicon Valley gegründet hatten1, war strikt gegen eine Fusion mit der halb maroden Computerfirma. Es kam zu einem beispiellosen Übernahmekampf. Man verunglimpfte sich, schließlich sogar mit Hilfe von Zeitungsanzeigen. Die Wellen schwappten sogar bis zu uns: 1 Meines Wissens nach die einzige echte Garagenfirma in Silicon Valley.

191

5.1

5


»In den letzten Tagen vor der Entscheidung bieten die Rivalen nochmals ihre ganze Kraft auf. Eine mehrseitige Zeitungsanzeige des HP-Managements zeigt die legendäre Garage im kalifornischen Palo Alto, in der Bill Hewlett und Dave Packard Ende der 30er Jahre mit ihrer Firma anfingen, sowie den Kaffee- und Kuchenimbiss in Houston, in dem vor 20 Jahren der Gründungsbeschluss für Compaq auf eine Serviette gekritzelt wurde. Auch jetzt gehe es wieder darum, mit dem Zusammenschluss ›Geschichte zu machen‹, wird an den Pioniergeist der Aktionäre appelliert. ›HP hat eine sonnigere Zukunft ohne Compaq‹, hält Walter Hewlett in seiner Anzeige dagegen.« – HP/Compaq: Die Woche der Entscheidung, Dietmar Mueller, 18.03.02, ZDNET.de Die Aktionäre beider Firmen mussten der Übernahme wenigstens mit einfacher Mehrheit zustimmen, damit der Deal der Managerin gelingen konnte. Der Deal gelang zwar, der Umbau von HP jedoch nicht. Am 9. Februar 2005 wurde Fiorina vom HP-Verwaltungsrat fristlos entlassen, weil sie angeblich vertrauliche Informationen an die Presse weitergegeben hatte. Zuvor war sie noch vom US-Wirtschaftsmagazin Fortune sechs Jahre hintereinander zur mächtigsten Frau der US-Wirtschaft gewählt worden. Erst kürzlich habe ich gelesen, dass HP den Smartphone-Hersteller Palm übernommen hat. Die Computergeschichte kennt keinen Stillstand. Auch Compaq ist wieder eine Computermarke. Nachdem der Name nach Fiorinas Weggang ganz zu verschwinden drohte, hat man bei HP den Entschluss gefasst, weltweit kostengünstige PC unter dem Namen Compaq anzubieten. So kommt Compaq wieder zu Ehren – die Firma, die auf einer Serviette gegründet wurde von Leuten, die beim Erfinder des ICs, des integrierten Schaltkreises, angestellt waren.

5.2

Mikroprozessoren

Sie sind das Herz des Computers, die Mikroprozessoren. Möglich wurden sie erst durch die sogenannten hochintegrierten Schaltkreise. Das ist ein kleines Stück Silizium, auf dem in mehreren Arbeitsschritten per Fotolithografie winzige Transistoren, Leiterbahnen und weitere elektronische Bausteine realisiert wurden. Sozusagen ein ganzer Computer auf einem Siliziumkristall, dem sogenannten Die2 (gesprochen: »dai«). 2 Ein »nacktes« Siliziumplättchen mit integrierten Schaltkreisen.

192

Quelle: www.google.com

Mikroprozessoren

Abbildung 5.2

5.2.1

Mit Golddrähten verlöteter Die des Intel 80486DX2-Prozessors

Die Entwicklung des Prozessors

Der Prozessor (CPU – Central Processing Unit – zentrale Steuereinheit) oder im Deutschen auch Recheneinheit genannt, ist der zentrale Baustein eines Computers. Er besteht aus dem Die, dem Siliziumplättchen mit den Schaltungen, das in ein Gehäuse eingeklebt und mit Golddrähten an größere Kontakte verlötet ist (siehe Abbildung 5.2). Diese enden in den Steckfüßen, mit denen der Prozessor in seinen Sockel auf der Hauptplatine des Rechners gesteckt wird. Bereits in Zuses Z1 war der Prozessor der wichtigste Bestandteil. Er führt die Rechenvorgänge aus, die der Nutzer vom Rechner ausgeführt bekommen möchte. Dazu fordert der Prozessor die Daten aus dem Speicher an, verrechnet sie und legt sie wieder im Speicher ab. Der Prozessor, die CPU, führt also nicht nur die Befehle des Nutzers aus, sondern steuert dabei im Grunde noch den gesamten Rechner. Deshalb ist der Prozessor eines Computers nicht unbedingt sein kleinster Bestandteil. Bei den allerersten Rechnern bestand fast der ganze Rechner nur aus CPU. Deshalb ging es bei der Miniaturisierung im Rechnerbereich in erster Linie darum, die CPU zu verkleinern. Neben dem geringeren Platzbedarf hat die Verkleinerung der CPU nämlich auch den Vorteil, dass der Rechner schneller wird, weil die Leitungen zwischen den CPU-Bestandteilen durch die Verkleinerung kürzer werden.

193

5.2


Bei den ersten Elektronenrechnern bestand die CPU aus Transistoren, die man besonders dicht zusammenlötete, dann verwendete man mehrere ICs. Der erste Prozessor, der nur aus einem IC bestand und der 1971 in den Handel kam, war der C4004 von Intel, ein 4-Bit-Mikroprozessor. Auf seinem Die waren nicht weniger als 2.300 Transistoren geätzt (siehe Abbildung 5.3). Intel entwickelte ihn im Auftrag des japanischen Tischrechnerherstellers Busicom. Aus einem Einfall heraus kaufte man den Entwurf zurück und schuf damit die Basis zur Entwicklung späterer Computerprozessoren, wie des 8080 (1974), der in einem der ersten Mikrocomputer, dem Altair 8800, genutzt wurde, bis zum heutigen Pentium.

Quelle: www.intel.com

5

Abbildung 5.3

Layout des iC4004

Der 4004 wurde noch bis 1986 produziert und als Steuerprozessor von Embedded Systems3 genutzt. Aber selbst heute ist er noch nicht ganz aus der Welt. Sammlerträume Karl Seidel tat sehr geheimnisvoll. Zu niemandem sagte er ein Wort über sein Vorhaben. Der Betrag, den er sich von seinem Sparbuch auszahlen ließ, war nicht gerade klein. Doch in diesem Falle kannte er keine Skrupel, schließlich hatte er das Geld für solche Fälle gespart. 3 Eingebettete Systeme sind Steuerungen und Computer, die in Maschinen integriert sind und zu deren Steuerung dienen. Meist arbeiten sie versteckt und sind fest programmiert.

194

Mikroprozessoren

Der Treffpunkt war nicht gerade vertrauenserweckend, eine heruntergekommene, von zwielichtigen Gestalten bevölkerte Eckkneipe in der Victoriastreet. Karl Seidel setzte sich wie vereinbart an den letzten Tisch, direkt neben dem Durchgang zu den Toiletten. So gut es ging versteckte er sich in dem hochgeklappten Jackenkragen. Die Minuten zogen sich immer länger, bis er sich schließlich doch eine Tasse Mokka bringen ließ. Als er die Tasse absetzte, stand plötzlich der Fremde vor ihm, den Hut tief ins Gesicht gezogen. Er lümmelte sich auf den Stuhl gegenüber und flüsterte: »Geld dabei?« Karl nickte. Der Fremde schob eine kleine Schachtel über den Tisch, Karl angelte eine Lupe aus seiner Jackentasche.


Die Schachtel enthielt ein Stück antistatischen Schaumstoff, auf dem ein weißes Rechteck prangte (siehe Abbildung 5.4).

Abbildung 5.4

Der iC4004

Karl ließ seine Lupe kreisen. Er studierte jeden Fleck auf dem kleinen elektronischen Bauteil. Auf dem golden glänzenden Rechteck in der Mitte des weißen Bausteins war der Schriftzug C4004 deutlich zu erkennen. Sein Atem stockte. Hier lag sie nun vor ihm, die Legende, der erste Intel-Mikroprozessor, der erste frei käufliche Mikroprozessor der Welt und damit der Beginn des modernen Computerzeitalters. Ein 4-Bit-Datenbus, 4 KB Programmspeicher, adressierbar, bestückt mit 2.300 Transistoren und am 15. November 1971 auf den Markt gebracht. Wie oft war er bereits kopiert worden, wie oft Sammler schon mit leeren Attrappen betrogen worden? Karl zog sein Notebook aus der Tasche, an dem er einen Sockel für ICs befestigt hatte. Ein paar Tastendrucke, und er wusste, dass dieser Prozessor echt war und noch funktionierte. Ein grauer Umschlag wechselte den Besitzer, und Karls Sammlung von Prozessoren war um eine Rarität reicher. In Gedanken sah er 195

5.2

5


schon die Tafel mit der langen Reihe der Intel-Prozessoren an der Wand seines Büros. Der Platz des ersten Prozessors war bis heute leer. Aber wenn er es recht überlegte, war er sich sicher, dass er das Original in dem kleinen Tresor im Nebenzimmer deponieren wollte, und an der Tafel würde eine Attrappe seinen Platz einnehmen. Ein Journalist fragt einen Wissenschaftler: »Wie schnell muss ein Supercomputer sein, damit er Erdbeben und Tornados vorhersagen kann?« »Er muss die Ergebnisse vor seiner Fertigstellung liefern.« – Anonymus Praxis: C4004 simulieren Der 4004 war von der japanischen Firma Busicom in Auftrag gegeben worden. Diese Firma hatte schon den ersten echten Taschenrechner entwickelt und baute mit dem 4004 den Busicom 141-PF, eine vollelektronische Tischrechenmaschine und ein weiterer Meilenstein in der Technikgeschichte. Im Internet kann man sich diese Maschine auf einer Webseite ansehen und, wenn man möchte, mit entsprechenden Chips emulieren: 왘

http://www.4004.com/busicom-replica.html#simulator

왘

http://www.4004.com/assets/busicom-141pf-simulator-w-flowchart071113.zip

왘

http://www.4004.com/busicom-simulator-documentation.html

Der 4004 eignet sich aber auch sehr gut, um sich anzusehen, wie so ein Mikroprozessor vom Prinzip her funktioniert. Da er recht einfach ist, kann man ihn auch noch mit akzeptablem Aufwand simulieren. Eine solche Simulation finden Sie unter http://www.4004.com/2009/i400x_analyzer20091114.zip. Die gleiche Datei findet man auch auf der Buch-DVD unter Software zum Buch\Kap05\ C4004\ i400x_analyzer20091114.zip. Nach dem Kopieren auf die Festplatte kann entpackt werden. Es kommen mehrere Dateien zum Vorschein. Der eigentliche Simulator ist die Datei i400x-analyser. Er ist ein sogenannter Logic-Analysator, der den Verlauf der Signale auf dem internen Bus, den Datenleistungen, untersucht und sichtbar macht. Er ist sehr sorgfältig erstellt und zeigt dem Ingenieur, wie das Layout des ersten Mikroprozessors aufgebaut ist und wie die gewünschten Signale mit Hilfe der einzelnen Transistoren auf dem Die erzeugt werden. Auch wenn es etwas anspruchsvoll ist, so kann man es sich dennoch ansehen. Zum Starten des Beispiels dient die Datei: mcs4_net_sample.bat. Mit ihr wird der Analysator gestartet und das Assembler-Programm sample.asm geladen.

196

Mikroprozessoren

Abbildung 5.5

4004-Analysator

Es werden mehrere Dialoge geöffnet. Sie zeigen neben dem Schaltbild der 4004 ROM- und RAM-Bausteine sowie die Signale und den disassemblierten Code des Programms. In dem Dialog mit der Bezeichnung Intel 4004 CPU Simulator und der Darstellung der Signale finden Sie im Menü die folgenden Punkte: Animation 폷 Start. Jetzt wird das Programm ausgeführt. Man sieht, welche Transistoren aktiv werden und welche Signalverläufe an den Leitungen auftreten. Im Prinzip kann man das Assembler-Programm ändern und sogar das Layout des Prozessors und das Verhalten genau untersuchen. Eine genauere Anleitung finden Sie in der Datei readme.txt.

5.2.2

Moderne Mikroprozessoren

Was damals noch mit 2.300 Transistoren auskam, besteht heute gleich aus Millionen und Abermillionen dieser Bausteine. Beispielhaft sei hier die Größe von zwei modernen Mikroprozessoren genannt: 왘

AMD Phenom II (Fläche: 2,58 cm², Anzahl Transistoren: 758 Mio.)

왘

Intel Core i7-980X (Fläche: 2,48 cm², Anzahl Transistoren: 1,17 Mrd.)

197

5.2

5


Man spricht im Zusammenhang mit einer so großen Zahl an Transistoren auf wenigen Quadratzentimetern von einer sehr hohen Packungsdichte. Für diese Packungsdichte gibt es jedoch keine Normzahl. Richtig messen kann man demnach nur die sogenannte Fertigungsgröße, die die Auflösung, also die Breite der aufgeätzten Leitungen, angibt. Hier bewegt man sich im nm-Bereich4 und stellt aktuell etwa im 30-nm-Bereich Prozessoren her. Wie ein solch hochintegrierter Prozessor aussieht, zeigt die Abbildung eines Sechskern-Pentium-Prozessors von AMD (siehe Abbildung 5.7). Der Pentium-FDIV-Bug Es war die Sensation im Büro des Prof. Thomas Ray Nicely vom Lynchburg College. Er konnte die Rechnung so oft ausführen lassen, wie er wollte, das Ergebnis war immer falsch. Der Fehler war am 13. Juni 1994 zum ersten Mal aufgetreten. Der Kalender zeigte inzwischen den 17. Oktober, und nach endlosen Testreihen und Verbesserungen an der Software stand fest, dass der Fehler irgendwie mit der Hardware zu tun hatte. Auf dem alten 486DX-33 des Professors war der Fehler bisher nicht aufgetreten. Heute hatte Prof. S. Fisher seinen neuen PentiumRechner ausgepackt, und Thomas Nicely hatte schon seit mehreren Tagen nervös auf diesen Zeitpunkt gewartet. Die Software war rasch installiert und gestartet. Wieder kamen die falschen Zahlen. »Das liegt am Pentium, eindeutig!« »Meinst du wirklich, Intel wäre ein so gravierender Fehler unterlaufen und die Recheneinheit wäre falsch verschaltet, so dass bei der Division immer dieser Fehler auftritt?« »Du sieht es ja.« »Das wäre eine Sensation.« Es war die Sensation. Für Thomas Ray Nicely stand fest, er würde die Weltöffentlichkeit darüber informieren müssen. Wenn er nur bei Intel anrief, würde man es abwiegeln und den Fehler verschweigen. Er musste den Konzern dazu zwingen, Farbe zu bekennen. So kam es, dass er am 30. Oktober 1994 wichtige Fachbuchautoren und IT-Fachjournalisten über seine Entdeckung informierte, insgesamt 12 Personen, und handfeste Beweise für seine Behauptung lieferte. Jeder, der wollte, erhielt ein kleines Programm, mit dem er selbst überprüfen konnte, wie »richtig« oder besser »falsch« der Pentium-Prozessor im eigenen PC rechnete.

4 nm = Nanometer = 1/1.000.000.000 Meter = 4 Atome nebeneinander oder 1/70.000 der Haardicke.

198

Mikroprozessoren

Die Meldung verbreitete sich wie ein Computervirus in allen Medien des Planeten, Radio und Fernsehen wetteiferten um Interviewtermine. Intel meldete sich mit der Aussage, bei einem Normalanwender und bei üblicher Software käme dieser Fehler statistisch nur alle 27.000 Jahre vor. Allerdings war es sehr schwierig, dies zu widerlegen. Später sollte sich IBM mit der Behauptung melden, dass der Fehler höchstens alle sechs Stunden vorkommen dürfte, wenn man Standardsoftware einsetzte. Die Problematik lag daran, dass die meiste Software zu der damaligen Zeit die Gleitkommaeinheit gar nicht nutzte, die der neue Pentium-Prozessor erstmals besaß. Das ist eine Recheneinheit, die beim Vorgängerprozessor noch fehlte und durch einen Arithmetikprozessor aufgerüstet werden konnte. Da Intel den Fehler laut eigenen Angaben schon vorher gefunden hatte, nämlich als man am Layout des Nachfolgeprozessors arbeitete, war man in der Lage, rasch einen Pentium anzubieten, der fehlerfrei arbeitete – was den Verdacht laut werden ließ, man habe den Fehler aus Kostengründen einfach bloß verheimlicht in der Hoffnung, dass er nie jemandem auffallen würde. Nun wollen Sie vielleicht einmal sehen, was Prof. Nicely anzeigen ließ, wenn der untersuchte Pentium fehlerfrei war. Kein Problem, seine Software liegt auf der Buch-DVD; das Einzige, was fehlt, ist ein Pentium, der den entsprechenden Fehler aufweist. Doch solche Rechner sind heute recht selten. Die Software liegt auf der DVD unter Software zum Buch\Kap05\pentbug.zip. Nachdem Sie die Datei entpackt haben – sie enthält ein unter DOS lauffähiges Programm, PENTBUG.EXE, sowie den C-Quellcode als pentbug.c – können Sie die Software in einer DOS-Konsole starten. Im Suchfenster des Startmenüs geben Sie cmd ein und wechseln in der Konsole zum Verzeichnis mit der pentbug-Datei, um sie zu starten: Pentbug.exe. Alternativ könnte man die Datei im Dateiexplorer durch einen Doppelklick aufrufen. Allerdings wird der Dialog sofort nach der Berechnung geschlossen, so dass man das Ergebnis nicht mehr sieht. Der Fehler tritt nicht bei jeder Berechnung auf, am ehesten bei Berechnungen mit Ergebnissen zwischen 824.617.131.197 und 824.633.720.797, weil bestimmte binäre Stellen in den Registern der Festpunkteinheit nicht richtig arbeiteten. Betroffen waren die Bitmuster: 0x8FFF, 0xA7FF, 0xBFFF, 0xD7FF, 0xEFFF

199

5.2

5


Abbildung 5.6

Auf der Suche nach dem Pentium-Bug

Die einfachste gefundene Berechnung, bei der ein Fehler auftrat, war: 4195835.0 / 3145727.0 Die Abfragen des Programms kann man einfach bestätigen (siehe Abbildung 5.6). In diesem Fall werden die vorgeschlagenen Defaultwerte benutzt. Das Programm teilt 4195835.0 durch Zahlen zwischen 3145720 und 3145730. Da es als Schrittweite 0,0625 verwendet, wird es 161 Divisionen durchführen. Die Ergebnisse werden mit Zahlen verglichen, die nicht über die Fließpunkteinheit berechnet wurden. Treten Unterschiede auf, gibt das Programm eine entsprechende Warnung aus. Immer kleinere Strukturen Der Pentium-Bug machte deutlich, dass hochkomplexe Konstrukte wie ein Prozessor sehr fehleranfällig sein können. Problematisch dabei ist nur, dass solche Fehler so versteckt vorliegen können, dass sie erst zutage treten, wenn man die betroffene Funktionalität benötigt. Noch ärgerlicher ist, dass man die Fehler schon deshalb nicht bemerkt, weil die gelieferten Ergebnisse so anspruchsvoll sind, dass man sie nicht ohne hohen Aufwand auf ihre Richtigkeit überprüfen kann. Nun lässt sich die Packungsdichte von ICs nicht beliebig erhöhen. Sie zu erhöhen bedeutet in jedem Fall, die einzelnen Bauteile auf dem IC zu verkleinern. Bei modernen Prozessoren spricht man von Giga(ntic) Scale Integration (GSI). Bei dieser Packungsdichte werden Milliarden Transistoren auf einem Chip unterge-

200

Mikroprozessoren

© AMD

bracht. Je kleiner die Bauelemente jedoch werden, umso höher muss die Auflösung bei der Lithografie in der Herstellung sein. Normales Licht reicht für die Belichtung schon lange nicht mehr aus. Deshalb setzt man zurzeit ultraviolettes Licht in der EUVLithografie (Extreme Ultra Violet Lithography) ein. Forschungen zur Röntgenlithografie sind im Gange. Dadurch kann man die Auflösung um eine weitere Potenz erhöhen. Allerdings stößt man auch hier unweigerlich an die Grenze, wenn es darum geht, eine Leiterbahn auf dem Silizium nur noch so breit zu machen, wie ein Siliziumatom dick ist. Ist die Auflösung bei der Herstellung kleiner Transistoren und Leiterbahnen nicht hoch genug, kommt es zu Ungenauigkeiten zwischen den Bahnen und beim Betrieb zu Kurzschlüssen, also zu hohen Ausschussraten.

Abbildung 5.7

Das DIE des AMD Opteron Six-Cores

201

5.2

5


Die Verkleinerung der Strukturen hat allerdings auch Vorteile: Kleinere Leiterstrecken sind kürzer, der Baustein also auch schneller. Man kann mit geringeren Spannungen und weniger Strom arbeiten, wenn die Strukturen entsprechend klein sind. Demzufolge hat man einen geringeren Stromverbrauch, aber auch weniger Wärmeentwicklung. Leider ist die Verkleinerung inzwischen an ihre Grenzen gelangt. EUVL arbeitet nur unter Hochvakuum exakt und ist demnach teuer, Röntgenlithografie ist bisher in der Massenfertigung nicht einsetzbar. Die Leistungssteigerung ist demnach in einer Sackgasse, aus der bis heute nur ein Ausweg gefunden wurde: paralleles Rechnen. Die Idee ist nicht ganz neu, und sie wurde auch schon vor Jahrzehnten beim Bau von Computern genutzt, freilich nur beim Bau von Supercomputern. Heute ist sie allerdings längst bei unserem üblichen Standard-PC angekommen. Hat man vor wenigen Jahren noch Hauptplatinen mit mehreren Sockeln für mehrere Prozessoren hergestellt, so bringt man heute die Prozessoren gleich in einem Gehäuse unter. Wobei das nicht ganz richtig ist: Man vervielfacht nämlich nicht einfach die gesamte Prozessorelektronik, sondern nur bestimmte Teile. Während man bloß eine Programmsteuereinheit benötigt, ist es sinnvoll, die sogenannten ALUs, die Recheneinheiten, mehrfach anzuordnen. Genauso wichtig ist es, für jede ALU eigene Registersätze zu haben. Die im Moment verbreitetsten Rechner sind die mit zwei Prozessorkernen, sie verfügen über sogenannte Dualcore-Prozessoren. Es gibt jedoch seit zwei Jahren auch schon Quadcore-Prozessoren, und man arbeitet bereits an Prozessoren mit wesentlich mehr Kernen. Interessant sind sie in jedem Fall für Server, die zahlreiche Aufgaben gleichzeitig durchführen müssen. Ob sie sich jedoch im Privatbereich so massiv durchsetzen werden, wie es sich die Industrie erhofft, bleibt fraglich, weil das immer stärker kommende Cloud Computing keine Hochleistungsprozessoren mehr beim Endanwender benötigt, sondern nur noch bei den Servern.

5.3

Workstation Clons

Der IBM-PC wurde ein Welterfolg. Merkwürdiger Weise nicht, weil IBM damals der größte Computerhersteller der Welt war, sondern weil es sich um ein Produkt handelte, das ungestraft kopiert werden durfte. Die dadurch entstehende Konkurrenz machte den PC von Jahr zu Jahr billiger, aber auch leistungsfähiger, so lange, bis ihn sich fast jeder leisten konnte. Was lag näher, als diese Erfolgsstory zu kopieren? 202

Vektor- und Parallelrechner

Die großen Workstation-Hersteller, wie z. B. Sun, deren Rechner in den Anfangsjahren des PCs um vieles leistungsfähiger waren als der beste IBM-Clone, rieben sich schon die Hände. Die Chips waren verfügbar, und die ersten asiatischen Hersteller hatten um 1990 begonnen, Rechner wie die SUN SPARCstation 1 zu kopieren. Allerdings blieb die Grafikleistung der Workstations bald hinter der der PCs zurück. Schon einfach deshalb, weil die Workstations von Haus aus keine zusätzliche Grafikkarte mit Grafikprozessor besaßen. In diesen Rechnern musste der Sparc-Prozessor die ganze Arbeit allein machen. Es gab zwar Grafikbeschleuniger-Karten, aber die waren teuer. PCs wurden viel schneller weiterentwickelt als Workstations, und so gerieten sie immer mehr ins Hintertreffen. Es gibt sie heute zwar immer noch, sie werden jedoch fast nur noch für Spezialanwendungen, wie z. B. im CAD-Bereich, eingesetzt. Lehrer: »Wer kann mir ein einzelnes Wort nennen, das ein Paradoxon ist?« Schülerin: »Supercomputer« – Anonymus

5.4


Parallelrechner sind durchaus keine neue Idee. Sogar Charles Babbage soll sich schon darüber Gedanken gemacht haben, wie er seine Analytical Machine dazu bringen könnte, mehrere Ergebnisse gleichzeitig auszurechnen. Ebenso John von Neumann, der sich aufgrund seiner Überlegungen zu zellulären Automaten sehr gut mit parallel laufenden Algorithmen auskannte. Er hätte gerne den realen Rechner dazu entwickelt, stellte aber fest, dass sich solche Rechner durch mehrfaches Einbauen gleicher Baugruppen über das Verhältnis verteuerten, und ließ die Pläne dazu in der Schublade.

5.4.1

Crays Erfindung

Die Stunde der Parallelrechner schlug aus einem anderen Grund noch nicht so früh, und dieser Grund hieß Vektorrechner und sollte vor allem einen Namen unvergessen machen: Seymour Cray. Er war kein Vertreter der MehrprozessorIdee. Wie damals weit verbreitet, war er der Meinung, dass die Kopplung vieler Prozessoren schwer zu programmieren sei und der Overhead, die Steuerung der Arbeitsverteilung auf die parallelen Prozessoren, unverhältnismäßig viel Leistung fordert und daher Parallelrechner im Grunde uninteressant sind. Deshalb favorisierte er den Bauplan des Vektorrechners.

203

5.4

5


Vektorrechner Im Prozessor des Vektorrechners sind die Register keine einfachen Werte, sondern Wertlisten. Man kann auch sagen, sie sind nicht eindimensional, sondern zweidimensional. Man kennt dieses vielleicht aus der Vektorrechnung im Mathematik- und Physikunterricht. Vektoren stellen dabei Größen auf einer Fläche oder im Raum dar. Neben ihrer Länge besitzen sie noch eine Richtung. Daher werden sie durch zwei oder drei Koordinatenpunkte dargestellt. Der Prozessor des Rechners ist ganz auf die Arbeit mit Zahlengruppen ausgelegt und, so verarbeitet er Vektoren statt einfacher Werte. Insbesondere für wissenschaftliche Berechnungen waren daher Vektorrechner hervorragend geeignet.

Crays Berufsleben begann mit einer Stelle bei der Engineering Research Associates, die einige Jahre später von der Remington Rand übernommen wurde. Bereits mit der Entwicklung seines ersten Rechners, des ERA 1103, errang Cray den Ruf eines genialen Rechnerkonstrukteurs. Nach der Firmenübernahme durch Rand verließen viele Kollegen die ERA. Einige gründeten 1957 die Control Data Corporation, kurz CDC, die bis 1992 existierte. Als Seymour Cray ebenfalls zu CDC wechselte, lieferte er 1960 den Entwurf für den CDC 1604. Es war zwar im Grunde nur ein verbesserter ERA 1103, aber sein nächster Entwurf, der CDC 6600, war so genial, dass der Rechner die Leistung aller anderen verfügbaren Rechnermodelle um eine Potenz übertraf. Damit war er der erste echte Supercomputer der Welt. IBM trat mit einem eigenen Supercomputer dagegen an, um seine Marktanteile zu sichern. Der CDC 6600 Der CDC 6600 war nicht nur der erste Supercomputer der Welt, er war auch der erste Rechner mit einem Monitor. Wie man damals sagte, mit einer CRT-Konsole, wobei CRT für den englischen Begriff »Cathode Ray Tube« steht. Das nutzten die Ingenieure dazu, um die ersten grafischen Spiele auf diesem Rechner zu entwickeln, so unter anderem Lunar Lander und Space Wars. Außerdem war der CDC 6600 einer der ersten Rechner, der über eine aktive Kühlanlage verfügte – worauf Seymour Cray bei allen späteren Rechnermodellen nicht mehr verzichten wollte.

Cray setzte die CDC 7600 dagegen, die über fünfmal leistungsfähiger war als der IBM-Großrechner und zehnmal so schnell wie die 6600. Obwohl Crays Rechner alle große Verkaufsschlager wurden, war die Finanzierung ihrer Entwicklung öfter fraglich und führte CDC fast in die Insolvenz. Bill Norris, der Chef von CDC, wollte sich auf ein weiteres Wagnis dieser Art nicht einlassen und mehr herkömmliche Großrechner entwickeln.

204


1972 trennten sich daher die Control Data einvernehmlich von Cray. Dieser gründete noch im gleichen Jahr die Firma Cray Research und machte sich an die Entwicklung eines ganz eigenen Rechners. Die ganze Computerwelt wartete mit Spannung darauf, was das »Wunderkind« Seymour Cray wohl auf die Beine stellen würde. Was kam, stellte auch wirklich alles in den Schatten, was sich die Informatiker in ihren kühnsten Träumen vorgestellt hatten.

© Rama; http://commons.wikimedia.org

Was sie 1976 mit der Cray 1 zu sehen bekamen, war eine Art aufgeschnittener Zylinderhut, der alles sein konnte, vom Kachelofen angefangen bis zur Duschkabine, aber gewiss kein Rechner. Das unglaubliche Ding hatte 133 MegaFLOPS, 8 MByte Hauptspeicher und 80 MHz Taktfrequenz. Heute klingt das harmlos, damals war es unbegreiflich. Zum Vergleich: Die CDC 7600 brachte es gerade mal auf 10 MegaFLOPS (Millionen Gleitkommazahl-Operationen pro Sekunde).

Abbildung 5.8

Die Cray 1

Eine mit den Wunschfarben des Kunden farblich dezent verkleidete Säule von 1,43 Metern Durchmesser und 1,95 Metern Höhe ragte aus einer 48 cm hohen, etwas mehr als halbrunden Sitzbank aus gepolsterten Ledersitzen hervor. Die Hohlsäule barg die Recheneinheit, die von der Mitte her verkabelt war. Alle Kabel waren aus Gründen der Signallaufzeit gleich lang und mussten daher in Schleifen gelegt werden (siehe Abbildung 5.9). Da der Hohlraum im Innern der Säule nicht viel Platz ließ, konnten nur extrem schlanke Personen die Verkabelung ausführen.

205

5.4


In der vorgelagerten Sitzbank war das Freon-Kühlsystem untergebracht, weshalb einige Zyniker auch von der Cray als von einem Kühlschrank für Vektorzahlen sprachen. Alles zusammen wog etwa fünfeinhalb Tonnen. Kurz gesagt, der Rechner war Kult, vom ersten Tag seiner Existenz an. Jedes Forschungsinstitut, das sich zur Weltelite zählte, wollte so ein Ding haben. Das erste Exemplar ging für 8,8 Millionen Dollar an das Los Alamos National Laboratory. Schon während Cray am nächsten Modell arbeitete, taten sich wieder Klüfte bei den Verfechtern der verschiedenen Rechner-Architekturen auf. Er war immer noch der Meinung, dass ein einziger Prozessor mit der entsprechenden Vektorrechenleistung besser sei als viele Prozessoren, die sich gegenseitig behindern. Um diese Hypothese zu veranschaulichen, stellte er oft die Frage: »Wenn Sie ein großes Feld pflügen müssen und sich die Zugtiere auswählen, was werden Sie wohl nehmen, einen starken Ochsen oder 1.024 Hühner?« Während er an der Cray 2 arbeitete, entwickelten einige seiner Mitarbeiter die 4-Prozessor-Maschine Cray X-MP.

© Cray Inc.

5

Abbildung 5.9

Die Cray 2 – Verkabelung in der Mitte

Die Cray X-MP hatte 800 MegaFLOPS und war von 1983 bis 1985 der schnellste Computer der Welt. Die Cray 2 brachte nur 488 MegaFLOPS, weshalb sich Cray dazu durchrang, sie so zu entwerfen, dass man die Zahl der Prozessoren vergrößern konnte. Im Endausbau besaß sie ebenfalls vier Prozessoren und war damit schneller als die Cray X-MP, der sie daher mit ihrem Erscheinen 1985 die Show stahl. 206


Seymour Cray Cray wurde am 28. September 1925 in Chippewa Falls, Wisconsin, als Sohn von Seymour und Lilian Cray geboren. Bereits mit zehn Jahren baute der technisch hochbegabte Junge in seinem Labor im Keller des Elternhauses ein Gerät, um Morsecode in Lochstreifen zu übersetzen. 1950 machte er seinen Abschluss als Elektroingenieur an der University of Minnesota. 1951 erwarb er an der gleichen Universität den Master in Mathematik. Seine erste Arbeitsstelle als Ingenieur trat er 1950 bei der ERA an, der Engineering Research Associates in St. Paul, Minnesota. Der erste Rechner, an dem er mitarbeitete, war der ERA 1103 (das Handbuch des baugleichen Univac 1103 liegt unter http://history.memphis.edu/mcrouse/survivor.html). Die Remington Rand kaufte die ERA auf. Cray schied 1957 bei der ERA aus und wechselte zur Control Data Corporation, die ehemalige Kollegen kurz zuvor gegründet hatten. Bei dieser Firma entwickelte er 1959 das Rechnermodell CDC 1604 und 1964 den CDC 6600, der als erster Supercomputer gilt. Ab 1968 arbeitete er an der CDC 7600 und begann sogar 1972 mit der Entwicklung der CDC 8600. Es kam jedoch anders. Control Data wurden die Entwicklungskosten an Crays Rechner zu hoch, und so verließ er 1972 diese Firma. Noch im gleichen Jahr gründete er die Cray Research Inc. und entwickelte mit dieser Firma zwei sensationelle Supercomputer-Modelle, die Cray 1 und die Cray 2. Die Entwicklung der Cray 3 führte, wie damals die CDC 8600, zu Kontroversen, und Cray verließ sein Unternehmen, um 1989 die Cray Computer Corporation zu gründen. Seinen Cray 3 konnte er zwar fertigstellen, der große finanzielle Erfolg blieb allerdings aus. So ging seine Firma CCC 1995 in Insolvenz. Trotzdem gründete er im gleichen Jahr noch das Unternehmen SRC Computer (Seymour Roger Cray Computer). Die Firma existiert noch heute und baut hochscalierbare Parallelrechner (http://www.srccomp.com). Cray starb am 5. Oktober 1996 im Alter von 71 Jahren an den Verletzungen, die er sich bei einem Autounfall zugezogen hatte.

Der aktuell leistungsstärkste Rechner der Welt, der Cray Jaguar, ist ein Produkt der Cray Research Inc., der ersten von Seymour Cray gegründeten Firma (http:// www.cray.com). Dieser Rechner besitzt nicht weniger als 37.361 Prozessorchips und 224.162 Prozessorkerne. Der Physiker Joel Birnbaum sagte einmal über Seymour Cray: »Es ist schier unmöglich, die Einflüsse zu beschreiben, die Cray auf die Entwicklung der Hochleistungs- und Superrechner genommen hat. Was heute ganz selbstverständlich ist, galt noch als völlig unmöglich, bevor Seymour es sich ausdachte.«

207

5.4

5


Als Cray sich an die Entwicklung der Cray 3 machte, gab er seinen Vorstandsposten auf, um sich ganz dem Bauplan des Rechners widmen zu können. Die Entwicklung des Rechners drohte jedoch unverhältnismäßig teuer zu werden. Besser für die Firma war die Weiterentwicklung der Cray X-MP. Das Problem war nicht neu für Seymour Cray, und er löste es auf die gleiche Weise wie zuvor: Er verließ die von ihm gegründete Firma und baute ein neues Unternehmen auf, die Cray Computer Corporation in Colorado Springs. Doch diesmal hatte er kein Glück. Die Cray 3 wurde kein finanzieller Erfolg, und bei der Entwicklung der Cray 4 ging ihm das Geld aus – er musste Konkurs anmelden. Inzwischen hatte er eingesehen, dass man mit der entsprechenden Software hochparallele Rechnersysteme leistungsfähiger machen konnte als Rechner mit nur einem Prozessor. Daher gründete er jetzt das Unternehmen SRC Computers für massiv parallele Systeme. Kurz nachdem er mit 71 Jahren sein neues Computersystem SRC 5 fertiggestellt hatte, verunglückte er am 5. Oktober 1996 bei einem Autounfall tödlich. Der Jeep Cherokee, mit dem er verunglückte, war eines der Automodelle, deren Konstruktion durch die simulierten Crashtests an seinen Cray-Rechnern zu den zukunftsweisenden Entwicklungen in der Autoindustrie zählte. Auch die Firma Cray baut inzwischen nur noch Parallelrechner, die Zeit der Vektorrechner ist eindeutig vorbei. Die Ära der Parallelrechner begann bereits in den 80er Jahren. Während Vektorrechner im Grunde immer die gleichen Rechenoperationen auf viele Daten der gleichen Art anwendeten, berechnen Parallelrechner gleichzeitig unterschiedliche Operationen an verschiedenen Daten. Das große Problem bei der Sache war, Programme zu schreiben, die eine ganze Schar von Prozessoren sinnvoll mit Arbeit versorgen können, ohne dabei Deadlocks5 zu erzeugen, und am Ende die Teilergebnisse sinnvoll zu einem Gesamtresultat zusammenfügen.

5.4.2

Aktuelle Entwicklung

Während es für die früheren Supercomputer spezielle Betriebssysteme, spezielle Programmiersprachen und Compiler gab, um Programme parallel abarbeitbar zu machen, so hat man inzwischen eine einfachere Lösung gefunden. Schließlich ist Software auf einem Computer in Schichten angeordnet. Die hardwarenächste Schicht stellt dabei keineswegs das Betriebssystem dar. Die unterste Schicht ist heute der sogenannte Microcode, das Programm, das die Maschinensprache 5 Deadlock steht für Verklemmung/Behinderung – mehrere Prozesse warten auf ein Ereignis, das nur von einem anderen, ebenfalls wartenden Prozess ausgelöst werden kann.

208


(Assembler) auf dem Prozessor realisiert. Wenn man nun statt auf dem Motherboard eine Handvoll Prozessoren unterzubringen, die Prozessoren auf einem Chip vereint und von einer Steuereinheit lenken lässt, die die Arbeit auf niedrigster Ebene auf die Prozessorkerne verteilt und entsprechende Befehle auf Maschinenebene zur Verfügung stellt, unterstützt der Mikrokode bereits die Paralellelisierung. Ganz ohne spezielles Programm für Parallelrechner geht es trotzdem nicht. Der Maschinencode kann auch hier nur unterstützen, er kann die Parallelisierung von Anwendersoftware nicht ersetzen.

Abbildung 5.10

Der Windows Taskmanager bei einem Sechskern-Prozessor

Wohin indes der Weg geht, wird immer deutlicher: Zur Cebit 2010 stellte AMD dem Fachpublikum seinen ersten 6-Core-Prozessor vor (siehe Abbildung 5.7). Und schon wird angekündigt, dass es in wenigen Jahren Prozessoren mit 126 Kernen geben wird. Für die echten Supercomputer ist das Peanuts. Aber auch hier zählt man inzwischen Prozessorkerne. Seit es die Multicores gibt, werden sie auch in den Numbercrunchern (Supercomputern) verbaut. Doch es sind unglaublich viele Multicore-Prozessoren, die sich verteilt auf unzählige Platinen bei der Arbeit dennoch zusammenfinden. Auf der Top500 – der Seite, auf der die 500 leistungsfähigsten Supercomputer dem Rang nach aufgelistet sind – sind sie alle friedlich vereint. Und was das Tollste daran ist: Seit November 2009 steht an allererster Stelle wieder ein altbekannter Name, nämlich Cray: http://www.top500.org/.

209

5.4


Der Cray XT5-HE Opteron Six Core 2.6 GHz Jaguar verfügt über 224.162 Prozessorkerne und leistet durchschnittlich 1.759.000 GigaFLOPS/sek. Seine Spitzenleistung liegt bei 2.330.000 GigaFLOPS/sek, das sind in der neuesten Maßeinheit 2,33 PetaFLOPS und über zweitausend Trillionen Berechnungen pro Sekunde – nach amerikanischer Zählung. In Europa entspricht das zweitausend Billionen, also zwei Billiarden Berechnungen. Natürlich hat dieser Rechner auch eine eigene Webseite: http://www.nccs.gov/ computing-resources/jaguar/.

© Cray Inc.

5

Abbildung 5.11

Die Cray TX 5 Jaguar

Das NCCF.GOV ist das nationale Centrum für Computerwissenschaften der USA. Es benötigt immense Rechenleistungen, um die Forscher bei ihren Untersuchungen im Grenzbereich der modernen Chemie und Physik optimal unterstützen zu können. So sind bereits 28 Forschergruppen aus der ganzen Welt dabei, mit der Rechenzeit des Cray Jaguar ihre Forschungen auf allen Gebieten voranzutreiben. Man erwartet in den nächsten Jahren bahnbrechende wissenschaftliche Erkenntnisse auf dem Gebiet der Chemie, Klima- und Kernforschung, Materialwissenschaften, Physik, Gentechnologie, Bioenergie, Astrophysik, Geowissenschaften sowie Fusions- und Verbrennungsforschung durch den Einsatz des Cray-Superrechners. Mit dem Jaguar soll es auch möglich sein, die bekannten Klimamodelle mit bisher unerreichter Genauigkeit durchzurechnen und so Antworten auf die großen Fragen des Klimawandels zu finden.

210

Rechnende Netze

Von Seymour Cray erzählt man sich folgende Anekdote: Nachdem er gehört hatte, dass die gerade im Bau befindliche Cray für Apple bestimmt sei, um den nächsten Apple-Computer zu entwerfen, meinte er trocken: »Seltsam, ich verwende gerade einen Apple-Computer, um meine nächste Cray zu konstruieren.«

5.5

Rechnende Netze

Supercomputer waren von Anfang an eine sehr teure Angelegenheit. Die Cray 1 kostete bereits 8,8 Millionen Dollar, die neuesten Superrechner hatten Baukosten im Bereich von 700 bis 800 Millionen Dollar und kosten im Betrieb ebenfalls fast 300 Millionen Dollar pro Jahr. Eine Stunde Rechenzeit an einem Supercomputer kann durchaus mal 6.000 $ und mehr kosten. Daher kam man schon vor Jahren auf die Idee, einen Superrechner aus billigen Komponenten aufzubauen. Insbesondere durch die kostengünstigen PC-Clones wurde die Idee von Jahr zu Jahr interessanter. Inzwischen sind die Superrechner selbst aus Abertausenden Standardprozessoren aufgebaut. Und zwar so modular, dass man sie wie PCs aufrüsten oder umrüsten kann, wenn Intel oder AMD den nächsten Prozessor herausbringen. Die Billigvariante ist einfach das Zusammenstellen handelsüblicher PCs in großen Regalreihen. Entscheidend für die Leistungsfähigkeit ist dann allerdings die Geschwindigkeit des Netzes, das sie verbindet. Daher stellen große Serverfarmen sozusagen ebenfalls eine Art Supercomputer dar. Besonders interessant in dieser Hinsicht ist die Serverfarm der Google-Suchmaschine. Sie bestand bereits 2007 aus über 450.000 Rechnern und hatte damit eine Leistung von bis zu 100 PetaFLOPS. Sie wäre also selbst heute noch bei weitem der leistungsfähigste Rechner der Welt.

5.5.1

Computercluster

Cluster steht im Englischen für Haufen. Gemeint ist hier ein Haufen Rechner, die miteinander verbunden sind und alle Aufgaben gemeinsam erledigen. Das Zusammenschließen zahlreicher Rechner dient üblicherweise der Leistungssteigerung. Es kann aber auch darum gehen, Ausfallsicherheit zu gewährleisten. Ausfallsichere Cluster bestehen meist nur aus zwei Rechnern, die gegenseitig einspringen, falls der aktive Rechner Probleme bekommen sollte. Die Leistungssteigerung durch Clustering ist meist dort gefragt, wo man sich keinen Superrechner leisten kann. Daher findet man Cluster oft an Schulen und Universitäten (siehe Abbildung 5.12).

211

5.5


Quelle: www.liv.ac.uk

5

Abbildung 5.12

Cluster der Uni Liverpool aus handelsüblichen Dell-Rechnern

Prinzipiell kann man Cluster in homogene und heterogene Systeme trennen. Homogene Systeme bestehen aus einer Ansammlung gleicher Rechner mit dem gleichen Betriebssystem. Bei heterogenen Clustern ist unterschiedliche Hardware, meist auch noch mit verschiedenen Betriebssystemen, miteinander gekoppelt. Homogene Systeme sind bei gleichen Kosten leistungsfähiger als heterogene, weil ein großer Teil der Leistung durch notwendige Konvertierung innerhalb der Kommunikation verloren geht. Wie bei der Bezeichnung Server ist bei Cluster nicht nur die Hardware, sondern auch die Software gemeint, die den Rechnerverbund wie einen einzigen Rechner verfügbar macht. Clustersoftware wurde schon für die VAX angeboten. VAXCluster, die Software von damals, wurde weiterentwickelt und wird noch heute von HP unter dem Namen VMSCluster vermarktet. Vor VAXCluster gab es bereits 1977 von Datapoint unter dem Namen ARCnet eine allererste Clustersoftware. Spätere bekannte Entwicklungen sind Beowulf oder openMosix. Im Gegensatz zu dem bereits eingestellten openMosix bezeichnet Beowulf nicht die Software, sondern das gesamte Konzept.

212

Rechnende Netze

Donald Becker und Thomas Sterling entwickelten im Herbst 1993 bei der NASA eine Idee, um erforderliche Rechenleistung kostengünstig zu bekommen. Sie erfanden Konzepte, um handelsübliche Rechner zur Zusammenarbeit zu bewegen. 1994 begann die Arbeit am Beowulf-Projekt. Bis heute ist es ein gefragtes Modell, um Rechnerleistung und Ausfallsicherheit zu realisieren.

»3. März 2010, 19:18 Uhr Neues Botnetz mit 13 Mio. Rechnern aufgedeckt In letzter Zeit werden vermehrt große Botnetze aufgespürt, auf Kneber und Chuck Norris folgt nun »Mariposa« (Schmetterling) mit rund 13 Millionen betroffenen Rechnern, entdeckt wurde das Netzwerk von der spanischen Polizei und dem FBI. Kurios dabei: Das Netzwerk ist bereits seit langem bekannt und wurde einst als gefahrlos eingestuft. Diese Einschätzung vom Oktober 2009 stammt von John McDonald, seines Zeichens Sicherheitsexperte bei Symantec. McDonald stellte fest, dass Mariposa für Computer mit aktueller Sicherheitssoftware keine Gefahr darstellt, zumal die Sicherheitsfirmen das Netzwerk bereits im Auge hatten. Dennoch zählt Mariposa nun rund 13 Millionen Rechner, welche auf fast alle Länder der Welt verteilt sind. Zu den Opfern gehören nicht nur größere Unternehmen und öffentliche Einrichtungen, sondern auch über 40 große Banken. Dies gab die spanische Polizei nun bekannt, welche in Zusammenarbeit mit dem FBI nun auch drei Verdächtige festgenommen hat. Auch Privatpersonen zählen zu den Betroffenen, besonders Kontoinformationen wurden erspäht. Des Weiteren konnten die Betreiber des Botnetzes betroffene Rechner wohl aus der Ferne steuern, da sich das Botnetz eine Hintertür zu Nutze macht. Die Verbreitung von Mariposa erfolgte über Tauschbörsen, über Microsofts Instant Messenger – aber auch über Datenträger, die von einem infizierten Computer stammten und an einen anderen Rechner angeschlossen wurden. Rund 800.000 Daten von Opfern konnten auf dem Rechner des Hauptverantwortlichen sichergestellt werden, davon sind allein 200.000 aus Spanien. Der 31 Jahre alte Haupttäter ist laut der Polizei ein Kleinkrimineller, der die Daten weiterverkauft hat und sich des eigentlichen Ausmaßes kaum bewusst ist. Entsprechend den Angaben der Polizei hätte mit Mariposa aufgrund der Netzwerkgröße aber weitaus Schlimmeres angerichtet werden können.« – Quelle: www.computerbase.de Mit dem Internet kam auch die Idee, die Rechenleistung fremder Rechner anzuzapfen und für eigene Zwecke zu missbrauchen. Bereits vor dem Internet gab es

213

5.5

5


Programme aus dem Bereich CAD oder der Anwendungsentwicklung, die ihre Aufgaben über ein lokales Netz verteilen konnten. Die Idee dabei war, Rechner eines Netzes, die gerade nicht beschäftigt werden, in die eigenen umfangreicheren Aufgaben einzubinden. Was auf dem lokalen Netz funktioniert, ist auch im Internet möglich. Da man im Internet weltweiten Zugriff auf Rechner hat, kann es schwierig werden, die Erlaubnis des jeweiligen Rechnernutzers einzuholen. Daher sind kriminelle Geister auf die Idee gekommen, die zur Kommunikation im Rechnerverbund nötige Software einfach unbemerkt auf die jeweiligen Rechner zu schmuggeln. Viren sind dazu geradezu prädestiniert. Es wird aber auch freie Software verwendet, die neben ihrer offenen Funktionalität noch als Bot Client arbeitet. Lädt man sich solche Software aus dem Internet, macht man aus seinem Rechner ein Mitglied des jeweiligen Botnetzes. Laut PCWELT lieferte Vodafone zeitweise sogar Handys aus, auf deren Karte die Mariposa-Botsoftware enthalten war. Hier konnte sie zwar direkt keinen Schaden anrichten. Doch oft sind Bot Clients so angelegt, dass sie jederzeit Software nachladen können, die dann ihre schädliche Funktionalität entfaltet. Der Rechner, von dem aus ein solches Botnetzwerk gesteuert werden kann, wird als Command-and-Control-Server (kurz C&C Server) bezeichnet. Von einem solchen Server aus können Aufgaben über das Botnetz verteilt werden, gleichzeitig ist der Rechner Anlaufstelle für das Ergebnis der ausgeführten Aufträge. Fortschrittliche Botnetze können von dort aus sogar stillgelegt oder gelöscht werden. Botnetze erledigen im Bereich der Computerkriminalität zahlreiche Aufgaben: 1. Verbergen der URL eines Rechners, von dem aus eine kriminelle Handlung ausgeführt wird – eines der häufigsten Einsatzgebiete von Botnetzen. Angriffe werden über einen der Botrechner umgeleitet, so dass es aussieht, als kämen sie von diesem Rechner, so dass bei der Strafverfolgung der unwissende Besitzer des Bot Clients belangt wird. 2. Sehr oft werden Botnetze auch dazu gebraucht, illegale Daten abzulegen. Die jeweiligen Nutzer der Rechner wissen dabei natürlich wieder nicht, dass auf ihren Festplatten Pornobilder oder Ähnliches lagern. 3. Versenden von Mails, insbesondere von Spam- oder Phishing-Mails. Oft werden Botnetze von den Betreibern auch vermietet. Diese Dienste werden teilweise sogar offen im Internet angeboten. In solchen Fällen nutzt man die Bots oft zum Versenden von Massen-E-Mails. Unerwünschte Werbemails würden übliche Rechnerkonfigurationen wochenlang beschäftigen. Indem man die Mails auf ein Botnetz verteilt, damit jeder Rechner die Mail an die ihm

214

Rechnende Netze

bekannten Mailadressen versenden kann, lässt sich diese »Arbeit« viel effektiver erledigen. 4. Ausspionieren fremder Rechner, um an lukrative Daten zu gelangen, wie z. B. Kontodaten oder Ähnliches. 5. Datenkidnapping – ein weiteres Einsatzgebiet von Botnetzen. Es hört sich zwar an wie aus einem Science-Fiction-Film, ist aber durchaus Realität. Innerhalb oder außerhalb des Bootnetzes wird ein Rechner ausgewählt, auf dem offensichtlich wichtige, private Dateien ausgemacht wurden. Sie werden ohne Vorwarnung verschlüsselt. Danach sendet man dem Besitzer des Rechners eine Erpresser-E-Mail, in der man ihn auffordert, eine entsprechende Summe zu zahlen, um die Dateien wieder entschlüsselt zu bekommen. Es gibt noch weitere Anwendungsfelder für solche Netzwerke. Nicht zuletzt stellen sie eine Art Computer-»Schwarm« dar, der unabhängig von den einzelnen Rechnern eine Art Gesamtverhalten entwickeln kann. Die Rechenleistung solcher Botnetze kann durchaus beachtlich sein. Es wird geschätzt, dass den Computerkriminellen durch Botnetze mehr Rechenleistung zur Verfügung steht als den Wissenschaftlichen Instituten mit ihren Supercomputern. Das hat in zweierlei Hinsicht schlimme Auswirkungen: Verschlüsselungen können umso einfacher geknackt werden, je mehr Rechenleistung man zur Verfügung hat. Andererseits kann man, falls die entsprechende Rechenleistung verfügbar ist, auch so stark verschlüsseln, dass der Code nicht mehr zu knacken ist, was insbesondere auf das Datenkidnapping Auswirkungen hat. Einige Fachleute vermuten, dass sich diese Art der Computerkriminalität noch stark ausweiten wird. »Die Pacht für ein E-Mail-Botnetz, das etwa 1.000 Mails pro Minute versendet (bei 100 Zombie-Rechnern online) beträgt etwa 2.000 Dollar im Monat. Der Preis für ein fertiges Botnetz – ebenso wie die Ausleihgebühr – ist abhängig von der Anzahl der infizierten Computer. In englischsprachigen Foren erfreuen sich betriebsbereite Botnetze der größten Beliebtheit. Kleine ZombieNetze mit nur einigen hundert Bots kosten zwischen 200 und 700 Dollar, der durchschnittliche Preis für einen Bot beträgt 50 Cent. Größere Botnetze gehen für weitaus höhere Summen über den Tisch. Das Shadow-Botnet etwa, das von einem 19-jährigen Hacker aus den Niederlanden aufgebaut wurde und aus mehr als 100.000 Computern aus der ganzen Welt bestand, wurde für 37.290 Dollar verkauft. Eine Summe, für die manch einer sich ein kleines Häuschen in Spanien kauft – der Kriminelle aus Brasilien zog aber das Zombie-Netzwerk vor.« – Quelle: http://www.viruslist.com/de/analysis?pubid=200883656

215

5.5

5


Achtung! Um der Gefahr, in ein Botnetz aufgenommen zu werden, zu entgehen, sollte man im Internet die Firewall stets aktiviert und auf dem neuesten Stand halten. Das Gleiche gilt für einen guten Virenwächter. Es wird geschätzt, dass bereits jeder vierte PC ungewollt Mitglied in einem Botnetzwerk ist.

5.5.2

Computerschwärme retten die Welt

Was sich für kriminelle Machenschaften verwenden lässt, kann auch nutzbringend eingesetzt werden – wobei festzuhalten ist, dass der sinnvolle Einsatz solcher Botnetze entwickelt wurde, bevor man die Idee zu missbrauchen begann. Die Idee stammt ursprünglich von David Gedye und Craig Kasnoff, zwei Computer-Wissenschaftlern aus Seattle. Sie kamen im Jahr 1994 auf die Idee, für die Verarbeitung von gewaltigen Mengen an Messdaten einer Himmelssichtung mit dem Radioteleskop statt eines Superrechners einfach das Internet zu nutzen.

5.5.3

Grid-Computing

Im Gegensatz zum Computercluster ist ein Grid bereits schwerpunktmäßig Softwaretechnik. Ganz einfach, weil beim Grid-Computing vorhandene Hardware, nämlich das Internet, genutzt wird. Die Idee, Rechenleistung und die anderen Ressourcen von Rechnern über das Netz allen zur Verfügung zu stellen, war bereits die Grundüberlegung bei der Entwicklung des Internets (ARPANET). Eigentliche Impulsgeber waren Projekte, wie das Seti@home und ähnliche, auf die wir noch zu sprechen kommen werden. Seitdem ist Grid-Computing eine anerkannte Technik im Bereich des Hochleistungscomputings. Natürlich genügt es nicht, Rechner über ihre IP-Adressen zu verbinden und ihnen Aufträge zuzuweisen. Es muss einen zentralen Server geben, wie beim Botnetz, der die Aufträge vergibt, Ergebnisse zusammenführt und die Arbeit des Grids überwacht. Die Auslastung eines laufenden Grids kann man sich auf folgender Homepage ansehen:http://gridview.cern.ch/GRIDVIEW/dt_index.php. Eines der größten Systeme ist das LHC Computing Grid, kurz LCG. Es ist das Grid des LHC, des Large Hadron Collider. So nennt sich der neueste Beschleunigerring des Kernforschungszentrums CERN in der Nähe von Genf. Mit Baukosten von über 3,5 Milliarden Euro und 27 km Ringumfang gilt er als die größte jemals gebaute Maschine der Welt. Die scherzhaft »Urknallmaschine« getaufte Anlage musste jedoch nach gerade mal einer Woche Betrieb wieder abgeschaltet werden. Es gab einen Schaden am Kühlsystem der Anlage. Erst nach der über ein 216

Rechnende Netze

Jahr dauernden Reparatur konnte die Anlage wieder in Betrieb genommen werden. Die bei den Experimenten anfallenden Datenmengen sind so gewaltig, dass man Rechenpower aus Supercomputern, mehreren Clustern und Grids benötigt, um die Ergebnisse der Experimente in annehmbaren Zeiträumen auswerten zu können. Beim Grid LHC@Home kann jeder, sogar jeder Internetnutzer, der das möchte, mit seinem Rechner teilnehmen.

Abbildung 5.13

Das Grid der größten Maschine der Welt

In vielen Ländern ist man bestrebt, für die national angesiedelte Forschung per Grid-Computing vermehrt Rechenleistung zur Verfügung zu stellen, ohne teure Supercomputer kaufen zu müssen. Dazu gibt es zahlreiche nationale Grid-Initiativen (NGIs). Das deutsche NGI-Vorhaben trägt den Namen D-Grid-Initiative. Diese Initiative fördert in erster Linie Projekte aus Forschung und Industrie. Sie wird seit dem 1. September 2005 über das Bundesministerium für Bildung und Forschung (BMBF) durch Ausschreibungen gefördert. Software, mit der man ein Grid betreiben kann, ist oft freie Software und kann daher über das Internet bezogen werden. Experimente im häuslichen Rahmen werden freilich nicht sehr ergiebig ausfallen. 217

5.5

5


Abbildung 5.14

Homepage der D-Grid (http://www.d-grid.de/)

Bekannte Grid-Software ist beispielsweise Globus Toolkit 4 oder gLite. Ein vielgenutztes Client-Frontend und Entwicklertool für Grid-Software ist dagegen g-Eclipse. Das Internet ist in diesem Sinne der größte Computerschwarm der Welt. Schließlich funktioniert es so, dass Daten von zahlreichen Rechnern ausgetauscht werden, warum also nicht auch Daten, die verrechnet werden müssen? Bei der Idee ging man davon aus, dass man vielleicht ein paar Tausend Nutzer würde davon überzeugen können, ein Programm zu installieren, das Daten aus dem Internet empfängt, diese bei schlechter Auslastung des PCs verrechnet und schließlich wieder an den Server des Projekts zurücksendet. Es dauerte fünf Jahre, bis alle Bedenken aus dem Weg geräumt und die Software verfügbar war. Zwei Versionen der Software gab es: AstroPulse und Enhanced. Das Projekt selbst befasste sich mit der Suche nach außerirdischen Intelligenzen, nannte sich SETI@home und wurde von der University of California in Berkeley betreut. Mit AstroPulse (siehe Abbildung 5.15) wurde in breitbandigen Pulsen nach auffälligen Signalen gesucht und mit Enhanced im schmalbandigen Bereich. Beide Programme waren sogenannte Bildschirmschoner.

218

Rechnende Netze

Abbildung 5.15

Der AstroPulse-Bildschirmschoner – das erste SETI@Home-Programm

Das sind Programme, die ursprünglich entwickelt wurden, um das Einbrennen von Bildschirminhalten in die Maske der früheren Röhrenmonitore zu verhindern. Ließ man früher beim Verlassen des Arbeitsplatzes den Monitor laufen, so schädigte der Elektronenstrahl mit der Zeit die phosphoreszierende Schicht des Bildschirms. Dadurch kam es zu Schatten oder Phantombildern, die beim Arbeiten störend wirkten. Das versuchte man dadurch zu verhindern, dass man nach einer gewissen Zeit ohne Nutzereingaben ein Programm startete, das wechselnde Bilder auf dem Monitor anzeigte. Bei modernen Monitoren ist eine solche Maßnahme nicht mehr nötig, weil sie nicht mehr einbrennen können. Trotzdem werden Bildschirmschoner (engl. Screensaver) noch oft verwendet. Einmal, um zu verhindern, dass jemand sieht, was auf dem Bildschirm steht, wenn der Nutzer den Platz für längere Zeit verlassen hat, teilweise auch zur Unterhaltung, indem lustige Szenen abgespielt werden. Die Bildschirmschoner-Funktion bei SETI@home zeigt der Fortschritt der aktuellen Berechnungen an (siehe Abbildung 5.15). Man kann sie abschalten, damit dem Projekt noch mehr Rechenleistung zur Verfügung gestellt wird. Die Teilnehmer des Projekts boten ihre Rechenleistung kostenlos an. Somit war das Projekt die finanziellen Sorgen los und erregte weltweit hohes Aufsehen. Die Idee des GRID-Computing war geboren. Die Technik, wie sie auch dem SETI@Home-Projekt zugrunde liegt, galt bald als Prototyp einer neuen Art der Internetnutzung.

219

5.5

5


5.5.4

Das SETI-Projekt

SETI@Home ist ein Teilprojekt des SETI-Projekts. Es wurde am 12. Oktober 1992 zum 500. Jahrestag der Entdeckung Amerikas ins Leben gerufen.

Abbildung 5.16

Die Homepage des SETI@home-Projekts

SETI steht für Search for Extraterrestrial Intelligence, also für »Suche nach außerirdischer Intelligenz«. Eine Chance, Kontakt zu außerirdischen Wesen zu bekommen, ist die Untersuchung der Signale von Radioteleskopen. Für das Projekt wurden in erster Linie Daten des zweitgrößten Teleskops der Welt genutzt, des 300-Meter-Arecibo-Teleskops (siehe Abbildung 5.17) im Norden Puerto Ricos, einer zu Amerika gehörenden Karibikinsel.

Würde man dabei ein Signal finden, das keinen natürlichen Ursprung haben kann, so nimmt man zunächst einmal an, dass es außerirdischen Ursprungs sein dürfte. Es wird in den engeren Kreis von Signalen aufgenommen, die noch einmal genauer analysiert werden. Natürlich war das SETI-Projekt nicht von ungefähr ins Leben gerufen worden. Bereits 1977 hatte man ein Signal empfangen (Wow-Signal), das Anlass zu der Vermutung gab, man könne mit den entsprechenden Mitteln Signale von außerirdischen Intelligenzen empfangen.

220

5.5

© courtesy of the NAIC - Arecibo Observatory, a facility of the NSF

Rechnende Netze

Abbildung 5.17

Das Arecibo-Teleskop – Telefonzentrale zu den Außerirdischen?

Doch der Senat der USA strich das Geld für die SETI-Forschung im September 1993 radikal zusammen. Ohne die Idee zu SETI@home wäre die Suche damals bereits eingestellt worden. Das sogenannte SETI@Home-Classic-Projekt wurde am 15. Dezember 2005 offiziell eingestellt. Auch wenn das Projekt keinen echten Fund melden konnte, so wurden doch verschiedene Stellen im Universum entdeckt, die noch genauer analysiert werden müssen. Die Leistung des Projekts war jedoch in jedem Falle astronomisch: Es wurden etwa 2,3 Millionen Jahre Rechenzeit aufgebracht, die aus 1,84 Milliarden Resultaten von über 5,4 Millionen Benutzern bestand. Die Idee, die Rechner der Internetanwender zu nutzen, fand so viele begeisterte Anhänger, dass man sich in Berkeley dazu entschloss, die Software von SETI@home weiterzuentwickeln. Es entstand das Projekt BOINC (Berkeley Open Infrastructure for Network Computing). Bei diesem war es wichtig, die verteilte Technologie unabhängig von den einzelnen Projektsachverhalten, z. B. astronomischen Daten wie bei SETI@home, zu machen. Mit BOINC konnte man jedes denkbare Softwareprojekt verteilen und im Internet bearbeiten lassen.

221

5


Das Wow-Signal Es war ein normaler Forschungsalltag am Radioteleskop der Ohio State University. Die Forschungseinrichtung hatte den Spitznamen »Big Ear« bekommen, und dem sollte sie an diesem Tag alle Ehre machen. Das Teleskop war nicht wie moderne Teleskope als bewegliche Schüssel aufgebaut, sondern als Kreisausschnitt, der wie ein Apfelstück auf dem Boden stand. Es war eines der ersten großen astronomischen Radioteleskope. Trotz des einfachen Aufbaus lieferte es störungsfreie Himmelsdaten. Die analogen Radiodaten wurden von einem IBM 1130-Computer in Zahlenkolonnen umgerechnet und als Ziffernfolgen ausgedruckt. Auf diese Weise konnte man die Messergebnisse leichter überblicken. Einer der Astronomen, Jerry R. Ehman, der auch an der Entwicklung der Auswertungssoftware mitgearbeitet hatte, versah seinen Dienst. Das sogenannte kosmische Hintergrundrauschen, das vom Urknall übrig geblieben sein soll, erzeugte ein gleichmäßiges Chaosmuster auf der Druckerfahne. »Wow«, entfuhr es Ehman unbewusst. Nie zuvor hatte es eine eklatante Abweichung am linken Rand des Ausdrucks gegeben. Eindeutig ein Signal. Es verstärkte sich bis zu einem Maximum und wurde wieder schwächer. Da sich das Teleskop selbst und mit der Erde bewegte, musste eine Quelle weit außen genau so ein anund abschwellendes Signal verursachen, wenn sie vor der Teleskopfläche vorbeilief. Ein Signal aus der Nähe, selbst eines vom Mond hätte länger angedauert und eine Struktur gezeigt. Ehman kreiste die Stelle auf der Druckfahne ein und schrieb sein »Wow«dazu. Seitdem trägt dieses Ereignis die Bezeichnung Wow-Signal. Natürlich wurde das Signal intensiv untersucht und von zahlreichen Fachleuten beurteilt. Als Problem erwies sich, dass es nie wieder auftrat und auch von keinem anderen Radioteleskop, das zur gleichen Zeit in Betrieb war, gemessen wurde. Jerry Ehman selbst hat eine Webseite zum Wow-Signal ins Netz gestellt, in der er die Problematik um das Signal genau erläutert, man findet sie unter http:// www.bigear.org/wow20th.htm. Bis heute konnte keine schlüssige Erklärung für den Ursprung dieses Signals gefunden werden. So bleibt das Wow-Signal aber eine Rechtfertigung, um weiter intensiv nach eventuellen Signalen von intelligenten Lebewesen außerhalb unseres Sonnensystems zu suchen – auch wenn einige Astronomen inzwischen der Meinung sind, dass Radiosignale, wie sie von intelligenten Wesen ausgesandt werden könnten,

222

Rechnende Netze

© Jerry Ehman

bereits nach wenigen AE (astronomischen Einheiten)6 im sogenannten Hintergrundrauschen untergehen.

Abbildung 5.18

Foto vom Originalausdruck mit dem Wow-Signal

Praxis I: BOINC Vielleicht hatten Sie bereits bei dem Thema Botnetze den Wunsch, dabei zu sein. Manch einer ist wahrscheinlich dabei, ohne es zu wollen. Man kann sich zwar die Grid-Software downloaden, es gibt jedoch weit sinnvollere Möglichkeiten, sich mit dem Thema Grid-Computing auseinanderzusetzen. Beispielsweise könnten Sie sich in einem laufenden Grid-Computer-Netz zu einem interessanten Projekt integrieren. 6 1 AE = 150 Mio. km

223

5.5

5


Wer gerne nach außerirdischem Leben suchen möchte, braucht sich kein Fernrohr zu kaufen. Das erste SETI@Home-Projekt ist zwar seit Jahren abgeschlossen, es gibt jedoch ein Nachfolgeprojekt auf Basis der bereits erwähnten Software namens BOINC. Die Webseite ist: http://setiathome.ssl.berkeley.edu/. Dort gibt es auch einen Link zum Herunterladen der aktuellen BOINC- Software. Ersatzweise kann man sich diese auch direkt von der BOINC-Homepage holen: http://boinc.berkeley.edu/index.php.

Abbildung 5.19

Die Homepage der BOINC-Software

Eine Version von Anfang 2010 befindet sich auch auf der DVD zum Buch. Sie finden Sie unter Software zum Buch\Kap05\Boinc\boinc_6.10.18_windows_ intelx86.exe. (Die Versionen für Apple und Linux finden Sie im gleichen Verzeichnis.) Wer sich das Programm nur ansehen möchte, kann das natürlich auch auf einem virtuellen Rechner machen. Möchte man richtig teilnehmen, ist jedoch nur eine reguläre Installation auf dem Hauptbetriebssystem eines Rechners sinnvoll. Ansonsten kann keine Rechenleistung für SETI@Home abgezweigt werden. Nach dem Start des Installationsprogramms folgt der übliche Begrüßungsdialog (siehe Abbildung 5.20). Akzeptieren Sie die Lizenzbedingungen, und klicken Sie Next > an. Danach werden die Installationsverzeichnisse angezeigt. Mit Hilfe der Advanced-Schaltfläche können diese geändert werden, auch die Nutzung der GPU lässt sich aktivieren. 224

Rechnende Netze

Abbildung 5.20

Start des BOINC-Programms

Abbildung 5.21

Akzeptieren der BOINC-Lizenz

Praxis II: Rechnen mit der GPU Während AMD und Intel ihre ersten Sechskernprozessoren ausliefern, sind in den meisten Rechnern bereits Prozessoren, die über 30 Kerne haben, am werkeln. Man spricht allerdings von der GPU7 statt der CPU und von Recheneinheiten statt von Kernen. Zu dieser erstaunlichen Entwicklung der Prozessoren auf unseren Grafikkarten kam es, weil Computerspiele immer realitätsnähere Bilder benötigten. Da die Aufgaben der Grafikprozessoren nur einen engen Teilbereich der Aufgaben eines 7 GPU = Graphic Processing Unit

225

5.5

5


Prozessors umfassen, konnte man sie ganz speziell optimieren. So wurden sie mit der Zeit selbst leistungsfähiger als die üblichen Prozessoren der Rechner. Was lag nun näher, als für umfangreiche Berechnungen in Technik und Forschung die GPUs der Rechner zu nutzen? Zunächst entwickelten sich die Nutzer (in erster Linie Ingenieure und Forscher) selbst die passende Software, um ihre Berechnungen auf die Grafikkarte auszulagern. Der Grafikkartenhersteller Nvidia erkannte schnell, welches neue Einsatzfeld sich für seine Chips eröffnete und entwickelte die CUDA8-Technologie. In diesem Rahmen bietet Nvidia entsprechende Treiber und Entwicklungswerkzeuge, um die GPU ihrer Grafikkarten als Prozessor für Berechnungen einzusetzen. Solche Programme laufen bis zu zehnmal schneller als die gleichen Programme für die normale CPU.

Abbildung 5.22

GPU aktivieren und Verzeichnisse ändern

Nun beginnt bereits die reguläre Installation. Nach der Installation werden Sie einen Neustart machen müssen. Dabei kann es – insbesondere, wenn Sie die GPU einsetzen wollen – zu Problemen kommen. Wenn Sie mehrere Monitore an Ihrem Rechner betreiben, kann es sein, dass Sie zum Hochfahren des Systems bis auf einen Monitor alle stilllegen müssen.

8 CUDA steht für Compute Unified Device Architecture.

226

Rechnende Netze

Abbildung 5.23

Installation des BOINC-Programms

Abbildung 5.24

Neustart des Rechners

Wenn das System hochgefahren ist, wird BOINC zwei Dialoge öffnen und die Möglichkeit anbieten, sich bei einem Projekt anzumelden.

Abbildung 5.25

Auswählen von SETI@home

227

5.5

5


Es wird eine beachtliche Liste angezeigt, aus der man dann SETI@home auswählen kann (siehe Abbildung 5.25). Jetzt gilt es, ein Teilnehmerkonto einzurichten, dem man später den aktuellen Kontostand entnehmen kann (siehe Abbildung 5.26). Es wird nämlich eine Art Punktekonto über die Computerleistung geführt, die man zum Projekt beigetragen hat.

Abbildung 5.26

Einrichten eines Kontos

Danach fordert BOINC bereits Aufgaben von SETI@home an. Dazu versucht der Projekt-Wizard, den Kontakt zum Server des Projekts herzustellen. Gleichzeitig hat der BOINC-Manager seine Arbeit aufgenommen und lädt das erste zu bearbeitende Datenpaket vom Projektserver (siehe Abbildung 5.27). So klein der Dialog ist – er liefert doch zahlreiche Informationen. Im unteren Teil kann man das aktuelle Projekt sehen und andere Projekte auswählen, darüber wird der Status des aktuellen Projekts angezeigt. Die Verbindung mit dem Server und die zugeteilten Aufträge werden genau protokolliert und sind unter Messages einzusehen. Möchte man die Arbeit am Projekt zwischendurch stoppen, so klickt man auf Pause. Die wichtigsten Einstellungen finden Sie in aller Kürze unter Preferences. Ein Dialog mit umfangreichen Konfigurationseinstellungen steht unter Advanced View zur Verfügung. Wie Sie bereits bei der Anmeldung gesehen haben, gibt es eine ganze Reihe Projekte, die auf die gleiche Weise wie SETI@home die Rechenleistung privater Internetrechner verwenden können. 228

Rechnende Netze

Abbildung 5.27

Verbunden mit SETI@home

Einen Überblick über alle BOINC-Projekte bietet die folgende Homepage: http:// www.boinc-halle-saale.de/Hauptframe/BOINC-Projekte.htm. Eine weitere Übersichtsseite ist diese: http://de.boincstats.com/bam/.

5.5.5

Die Zukunft der Supercomputer

Macht man beispielsweise beim SETI@home-Projekt mit, ist der heimische Computer Teil einer der gewaltigsten Rechenmaschinen, die die Welt bisher gesehen hat: Das Projekt hat eine Rechenleistung von über 900 TeraFLOPS – sozusagen Supercomputing aus dem Arbeitszimmer. Einen Vergleich zeigt die folgende Tabelle: Name

Standort

Cray Jaguar

Oak Ridge 2.331 National Laboratory, USA

224.162

wissenschaftliche Berechnungen

Roadrunner

Los Alamos, New 1.375 Mexico, USA

122.400

Simulation von Atombombentests

Tabelle 5.1

TeraFLOPS Prozessorzahl

Aufgabe

Höchste Rechenleistungen (Quelle: http://www.top500.org/)

229

5.5

5


Name

Standort

TeraFLOPS Prozessorzahl

Aufgabe

Cray Kraken XT5

Universität von Tennessee, USA

1.028

98.928

wissenschaftliche Berechnungen

JUGENE

Forschungszentrum Jülich (Deutschland)

1.002

294.912

Materialwissenschaft, Chemie, Elementarteilchenphysik, Umwelt, Astrophysik

über 900

5,4 Mio.

Suche nach Außerirdischen

SETI@Home weltweit Tabelle 5.1

Höchste Rechenleistungen (Quelle: http://www.top500.org/) (Forts.)

Momentan ist der Cray Jaguar noch der leistungsstärkste Superrechner der Welt. Seine Rechenleistung entspricht etwa dem 100.000-fachen eines modernen Personal Computers. Die Anschaffungskosten betragen jedoch ein Mehrfaches davon, rund 800 Mio. $. Es bleibt abzuwarten, in wieweit die Entwicklung der Supercomputer auf diese Weise kontinuierlich fortschreiten wird. Vom Prinzip her sind sie nicht mehr als PC-Prozessoren, die in unglaublich großer Zahl zusammengekoppelt sind. Daher wird vermutet, dass es bald keine Supercomputer mehr geben wird. Die Rechenleistung des Internets ist ohnehin um ein Vielfaches höher und steht praktisch kostenlos zur Verfügung. In Zukunft werden also spezielle Programme wie BOINC Supercomputer überflüssig machen. Das Tolle daran ist: Sie können heute schon daran teilnehmen, egal, ob Sie nach Außerirdischen suchen oder die Welt retten, indem Sie mit Ihrem Computer helfen, im Sonnensystem Felsbrocken aufzustöbern, die auf die Erde stürzen könnten. Sie brauchen nicht zu programmieren und auch keine anderen Arbeiten auszuführen. Sie lassen nur Ihren Rechner in der Zeit, in der Sie ihn nicht brauchen, für das Projekt rechnen. Aber vergessen Sie über der Rettung der Erde bitte nicht, das Buch weiterzulesen. Mit BOINC haben wir nämlich nicht nur an einem Supercomputer teilgenommen, sondern auch die Grenze von der Hardware zur Software praktisch überschritten. Wir waren Teil einer virtuellen Superrechenmaschine, die zwar auf unserer Hardware lief, aber nur durch eine spezielle Software realisiert werden konnte. Ähnlich wie bei der Virtualisierung – ein Rechner auf Softwarebasis. »Ein Supercomputer wird in der Tat eines Tages die Welt retten. Allerdings nur, wenn sie vorher ein Vorgängermodell in Gefahr gebracht hat.« – Anonymus

230

Noch mehr Spaß: Eigene Cray gefällig?

5.6

Noch mehr Spaß: Eigene Cray gefällig?

Bestimmt befinden sich unter meinen Lesern einige, die mir noch immer übel nehmen, dass ich den Pentium-PC unter das Kapitel »Supercomputer« gepackt habe. Vielleicht erst recht, nachdem in diesem Kapitel Rechner wie die Cray Jaguar vorkamen, der schnellste Rechner der Welt. Für diese Leser habe ich ein kleines Bonbon, Sie müssen allerdings ein wenig Platz unter Ihrem Schreibtisch schaffen. Ich möchte Ihnen einen PC empfehlen, natürlich einen ganz besonderen. Er ist verhältnismäßig klein und verbraucht leider ein wenig mehr Strom als mein Notebook, sonst würde ich mich vielleicht auch noch neu verlieben.

© Cray Inc.

Um die Spannung etwas zu erhöhen: Hier ist erst einmal ein Passbild von dem Schmuckstück.

Abbildung 5.28

Die Cray CX1

Ja, Sie haben ganz richtig gesehen: Es ist eine Cray, und sie ist auch keine 150 Meter lang und breit und braucht keine Halle und fast kein Kraftwerk, um in Betrieb genommen zu werden. Aber sie ist auch kein PC, sondern ein echter Supercomputer, auch wenn sie als Betriebssystem nur Windows 7 oder Linux benutzt. Cray CX1 – technische Daten: 왘

2 x 8 Intel®-Xeon®-Prozessoren 5500 à 2 oder 4 Cores

왘

24 GB Hauptspeicher

왘

4 x 1 TB Festplatten

231

5.6

5


Natürlich ist so ein Rechnerchen nicht ganz billig, aber wer braucht schon ein neues Auto, wenn er sich für 12.000 $ eine Cray unter den Schreibtisch schieben kann? Rechnen für die Megamaschine Natürlich möchte ich Ihnen nicht verheimlichen, wie man mit dem heimischen PC an der Entschlüsselung des Urknalls teilnehmen kann und seinen Computer als »freien Mitarbeiter« für das Kernforschungszentrum CERN zur Verfügung stellt. Näheres dazu finden Sie auf der Homepage: http://lhcathome.cern.ch/ lhcathome/.

Abbildung 5.29

Homepage des LHC@home-Projekts

Mit der neuen BOINC-Software ist es ganz einfach: Man addiert ein zusätzliches Projekt über die Add Project-Schaltfläche und wählt dabei LHC@home aus. Möchte man eine ältere BOINC-Software nutzen, kann es notwendig werden, sich beim Projekt selbst anzumelden. Dazu gibt es den Link Your account links oben auf der Webseite. Damit legt man sich zunächst einen Acount an. Mit den Zugangsdaten ist es möglich, ins LHC@home-Projekt mit einer alten BOINC-Software einzusteigen.

232

Lesen Sie weiter

Abbildung 5.30

Einloggen beim LHC

Vielleicht sind es ja gerade die Berechnungen, die auf Ihrem heimischen PC ablaufen, die mithelfen, die Weltformel zu finden und die letzten großen Geheimnisse der Physik zu lüften. »Manche Menschen äußern Bedenken, künstliche Intelligenz würde uns so weit bringen, uns minderwertig zu fühlen. Wieso? Es fühlt sich doch auch niemand jedes Mal minderwertig, wenn er eine Blume sieht.« – Alan Kay (Smalltalk-Papst)

5.7

Lesen Sie weiter


Beschreibung

http://www.4004.com/

Seite zum C4004

http://www.bios-kompendium.de/ download/dlkomp.htm

Seite speziell zu Bios-Problemen

http://www.computer-archiv.de/

deutsches Computerarchiv

http://www.drcrazy.de/nkc/

der NDR-Kleincomputer

233

5.7

5


URL

Beschreibung

http://de.wikibooks.org/wiki/ Computergeschichte

Computergeschichte, Projekt im Aufbau

http://forum.chip.de/cpu-board-speicher/ ein Sammelgebiet entsteht bekommen-cpus-sammlerwert-562582.html http://www.bernd-leitenberger.de/ pc-hist1975-1981.shtml

Seite zur PC-Geschichte

http://www.bios-kompendium.de/ download/dlkomp.htm

IT-Geschichte und Sammlerseiten

http://www.cpu-collection.de/

Liste der meisten CPUs

http://www.trnicely.net/pentbug/ pentbug.html

FAQ von Prof. Nicely zum FDIV-Bug

http://de.wikipedia.org/wiki/PentiumFDIV-Bug

Wikipedia-Seite zum FDIV-Bug

http://www.nccs.gov/computing-resources/ Homepage des schnellsten Rechners jaguar/ http://www.beowulf.org/overview/ index.html

Seite des Beowulf-Projekts

http://www.microsoft.com/hpc/en/us/ default.aspx

Microsoft-Clusterseite

http://sugi.dgrid.de/

E-Learning zum Grid-Computing

http://www.andreadrian.de/schach/

Geschichte des Computerschachs

http://www.bigear.org/default.htm

Webseite des Big-Ear-Radioteleskops

http://www.planetary.org/programs/ projects/ setiathome/setiathome_ 20080827.html

Planetenforscher-Seite zu SETI@home

http://seti.berkeley.edu/

Hauptseite der SETI-Projekte

http://setiathome.ssl.berkeley.edu/

Homepage des SETI@Home-Projekts

http://www.eclipse.org/geclipse/

g-Eclipse-Homepage

http://www.d-grid.de/

Homepage der D-Grid-Initiative

http://www.viruslist.com/de/analysis? pubid=200883656

Webseite zu Botnetzen

234

TEIL II Geschichte der Software

»Es gibt zwei Arten von Software: die schlechtere, die du gerade gekauft hast – und die bessere, die kurz danach auf den Markt kommt. – Willy Meurer (*1934), deutsch-kanadischer Kaufmann

»Nicht einmal der PC kommt ohne Papierkorb aus.« – Peter F. Keller (*1949), Schweizer Autor

»Software ist eine großartige Erfindung. Es passieren genauso viele Fehler wie früher, aber keiner ist mehr da, dem man die Schuld daran geben könnte.« – Anonymus

»Lady Ada gilt gemeinhin als die erste Computer-Programmiererin, wen wundert's, wenn der Bug1 ebenfalls von einer Frau erfunden wurde.« – Anonymus Programmiersprachen sind Hammer und Meißel des Computerzeitalters. Sie stellen – universell nutzbar – die Speerspitze des Fortschritts in der permanenten Weiterentwicklung der Software dar. Die Entwicklung einer neuen Sprache hat mit der entsprechenden zeitlichen Verzögerung stets auch eine revolutionäre Weiterentwicklung der Anwendersoftware zur Folge.

6

Von Lady Ada bis F#

1942

1946

1954

1960 1964

1973

1995

2009

Maschinensprache Assembler Fortran Cobol Basic

C Java/Eclipse F#

6.1

Das rasende Herz

Computer – das ist das, was sich im Blechgehäuse unter dem Schreibtisch befindet. Genau wie eine Waschmaschine besteht ein Computer aus verschiedenen Teilen, die alle unterschiedliche Aufgaben erfüllen. Im Gegensatz zur Waschmaschine bearbeitet er jedoch statt Wäsche Informationen. Darum kann er uns auch 1 Kurzwort für Fehler im Programm

237

6

Von Lady Ada bis F#

darüber informieren, was in seinem Innern steckt, ohne dass wir ihn dazu aufschrauben müssen.2

Abbildung 6.1

Pentium II-Prozessor2 von Intel (1998)

Solche Programme nennt man Hardware-Analysetools. Bekannte Hardware-Analysetools sind die folgenden: 왘

Dr. Hardware

왘

Everest

왘

PC Wizard

Abbildung 6.2

Prozessor-Daten aus Everest

2 Nicht der neueste, aber eindeutig der schönste Intel-Prozessor.

238

Das rasende Herz

6.1.1

Der Prozessor

Wenn man sich auf diese Weise die inneren Qualitäten seines Rechners anzeigen lässt, stellt man fest, dass es über den sogenannten Prozessor das meiste zu erzählen gibt (siehe Abbildung 6.2). In der Tat ist er das Herz des Rechners, mehr noch sein Gehirn. Der Prozessor ist der eigentliche Rechner, er führt die Rechenvorgänge aus. Der Hauptspeicher dient dazu, die Daten, die er verarbeitet, zu speichern. Die IO-Bausteine und der Bus sind nur dazu da, den Prozessor mit anderen Computerbauteilen, wie der Festplatte oder dem DVD-Laufwerk, zu verbinden. Auch alle Befehle, die man als Nutzer in den Rechner eingibt, landen am Ende im Prozessor. Freilich versteht dieser die Befehle des Programmierers nicht direkt. Sie müssen erst mit Hilfe eines Übersetzungsprogramms in sogenannte Maschinensprache umgewandelt werden. Diese Sprache besteht aus den Anweisungen, die im Steuerwerk eines Prozessors direkt ausgeführt werden können. Wenn man so will, ist sie die erste Programmiersprache, die in der Geschichte des Computers auftauchte. Wie alles, was im Innern des Computers abläuft, besteht sie aus Nullen und Einsen. Praxis: Im Inneren des Prozessors Es gibt sehr schöne Computermodelle, die die Abläufe innerhalb des Prozessors anzeigen und mit denen man erste Programmierversuche durchführen kann. Eines dieser Modelle wollen wir nutzen, um die Vorgänge innerhalb des PC-Prozessors sichtbar zu machen. Sie finden es im Internet unter http://abs.informatik.uni-freiburg.de/teaching/ Neumi. Es liegt aber auch auf der DVD bereit: Software zum Buch\Kap06\PCSimulation\neumi\Neumi.jar. Wie jede jar-Datei wird auch sie gestartet über java -jar Neumi.jar

Ein Dialog wird geöffnet, der uns schematisch das Innere eines Prozessors zeigt. Das bestimmende Element ist die sogenannte ALU, die Arithmetisch Logische Einheit. Das sind die Transistoren im Prozessor, die die eigentlichen Berechnungen ausführen. Das ganze Drumherum dient nur dazu, der ALU die Daten im richtigen Moment zur Verfügung zu stellen (siehe Abbildung 6.3). Die rechteckigen Felder am oberen Rand sind die sogenannten Register. Das sind ganz schnelle Zwischenspeicher, die Daten für die ALU bereithalten oder die Adressen für die Programmabarbeitung. Sie werden immer mit Abkürzungen

239

6.1

6

Von Lady Ada bis F#

benannt. ACC, der Akkumulator, ist im Grunde das wichtigste Register. Er dient als allgemeiner Zwischenspeicher. Führt man beispielsweise eine Reihenaddition durch, landet dort immer das Zwischenergebnis für die nächste Addition. Auch bei anderen Arbeiten wird meist der ACC verwendet, bevor ein Wert durch die ALU läuft.

Abbildung 6.3

Neumi nach dem Start

Das PC-Register (Program Counter) dient dazu, die Speicheradresse zu verwalten, in der der gerade abzuarbeitende Befehl steht. Dieses Register zählt damit sozusagen das abzuarbeitende Programm durch. Wenn man startet, steht dort eine 0 in einem gelben Feld. Das ist die Adresse, bei der ein geladenes Programm beginnt. Das I-Register (Instruction Register) ist das Befehlsregister, das die auszuführenden Befehle aufnimmt. IN1–IN2 sind allgemeine Register, die bei Rechenoperationen genutzt werden können. Die Tabelle unterhalb der ALU stellt einen Ausschnitt aus dem Hauptspeicher dar. Die Schaltflächen für die Bedienung liegen rechts oben. Darunter befinden sich ein Schieberegler für die Geschwindigkeit und daneben das Tracefeld für die Protokollierung.

240

Das rasende Herz

Um die Programmierung zu beginnen, klicken Sie in den Speicher, in dem zu Anfang nur Nullen stehen – in Form der DW0, was für Doppelwort 0 steht. Ein Editor öffnet sich. Wir geben folgendes Programm ein (die Kommentare hinter dem ; können weggelassen werden, sie dienen nur der Erläuterung): ; Eine einfache Addition von 27 mit 13 ; Der erste Wert wird aus dem Speicher in den ACC geladen LOAD ACC, A ; 161 = HEX A1 in den Akkumulator laden ; Accumulator mit 16 = HEX 10 addieren OPLUS ACC, B ; ACC = A plus B ; Das Ergebnis der Addition in Speicherplatz A ablegen STORE A ; [A] = 161 plus 16 ergibt B1 = 177 DW 0 ; Der ; Die A: B:

Speicherbereich hinter dem Programm mit Daten für das Programm hexadezimale Darstellung der Zahl: DW A1H DW 10H

Wenn wir alles richtig eingetippt haben, können wir das Assembler-Programm abspeichern und assemblieren über: Assembler 폷 assemblieren (ins RAM). Nun sollte im simulierten Speicher das Programm angezeigt werden. Wer das Programm lieber von der DVD laden möchte, findet es unter Software zum Buch\Kap06\PC-Simulation\neumi\einfacheAddition.retii. In der ersten Spalte steht die Speicheradresse, in der zweiten der Maschinencode dezimal, und die dritte Spalte zeigt für uns noch einmal erläuternd den Assembler-Code des Ganzen. Nun gilt es nur noch den Start-Button anzuklicken. Schon sieht man, wie der erste Befehl, der Befehl auf Speicherstelle 0, aus dem Speicher geholt und in das Befehlsregister gelangt. Im wahren Leben ist das natürlich etwas komplizierter. Man spricht vom Steuerwerk, dem Teil, der den Prozessor steuert. Der Befehl wird ausgeführt, indem der Inhalt der vierten Speicherstelle in den ACC transportiert wird. So geht das weiter, bis das ganze Programm abgearbeitet ist, und darüber hinaus, bis wir den Rechner anhalten. Im gleichen Verzeichnis auf der DVD liegen noch zwei Beispielprogramme: 왘

XOR_Swap

왘

Kopier_dich_selbst

Aber auch eigene Programmideen lassen sich mit Neumi leicht verwirklichen.

241

6.1

6

Von Lady Ada bis F#

6.1.2

In Kurzform: Assembler

Das Modell zeigt sehr schön die Arbeit des Prozessors. Wie Prozessoren sich selbst mit Microcode und dem Steuerwerk steuern, ist eine Geschichte für sich, die an dieser Stelle zu weit führen würde. Wir nehmen halt hin, dass sie die Befehle ausführen können, die sie im Speicher finden. Die Befehle werden im RAM in Dezimalzahlen angezeigt, nicht in binärer Maschinensprache, daneben steht der Assembler-Code. Diese Sprache besteht statt aus 0-und-1-Folgen aus Befehlskürzeln, die vom Assembler-Programmierer viel leichter zu verstehen sind. Für uns ist es natürlich auch einfacher. Statt 10100100000010000011000100 heißt es einfach LOAD ACC 4, für »Lade den Wert aus Speicherstelle 4 in den Akkumulator« heißt es in Assembler LOAD ACC, A. »Unsere Tester finden sogar die Fehler, von denen die Programmierer sicher sind, dass sie die nicht reingemacht haben.« – Bill Gates *** »Mir würde es genügen, wenn sie die finden würden, die die Programmierer reingemacht haben.« – H. R. Wieland Assembler nennt man die Kürzelsprache ebenso wie das Programm, das die geschriebenen Assembler-Anweisungen – man spricht auch vom Quellcode – in Maschinensprache-Dateien umwandelt. Diese Dateien haben unter Windows stets die Endung .exe, was für ausführbare Programme steht. Meist nennt man sie einfach nur Programme. Auch die erste Programmiererin, Lady Ada Augusta, Countess of Lovelace (wir haben sie in Kapitel 2, »Computer ohne Programme«, kennengelernt), hätte ihre Programme, die sie meist nur in mathematischen Formeln darstellte, sicher in einer Kurzform, also in Assembler, realisiert, wenn es zur Fertigstellung von Babbages Maschinen gekommen wäre. So hat sie zwar in gewisser Weise programmiert, aber noch keine Programmiersprache genutzt. Assembler war gut geeignet, um schnelle Programme zu einfachen mathematischen Problemstellungen zu schreiben. Wollte man eine Textverarbeitung oder ein Datenbankprogramm erstellen, war Assembler denkbar ungeeignet. Selbst bei komplexen mathematischen Problemen wurde die Assembler-Programmierung zu einem Großprojekt. Was lag also näher, als eine Möglichkeit zu schaffen, diese Probleme einfacher zu formieren und den Computer zu bemühen, um aus den Beschreibungen Maschinensprache zu machen.

242

Das rasende Herz


Diese Arbeit sollte eine Art Übersetzer machen, der den Namen Compiler erhielt.

Abbildung 6.4

6.1.3

Lady Ada Augusta, Countess of Lovelace

Die erste »höhere« Sprache: Fortran

So kam es, dass 1957, im Jahr des Sputniks, auch die erste höhere Programmiersprache veröffentlicht wurde, die Programmiersprache Fortran. Sie wurde 1954 unter Leitung von John W. Backus bei IBM entwickelt. Backus hat die Idee dazu selbst entwickelt. Ansätze zu Programmiersprachen hatte es kurz zuvor schon gegeben. Den ersten Compiler hatte Grace Hopper (die Dame mit der Motte) bereits 1952 entwickelt. Praxis Auch wenn der Name Fortran schon antiquiert klingt, die Sprache wird noch heute eingesetzt. Immer, wenn es um Programme mit mathematischem Hintergrund geht, ist Fortran die richtige Wahl. Dabei ist gleich, ob man einen PC oder

243

6.1

6

Von Lady Ada bis F#

einen Supercomputer programmieren will, Fortran ist für alle Architekturen verfügbar. Einen freien Fortran-Compiler findet man beispielsweise unter http://www.guilherme.tk/, aber auch unter folgendem Verzeichnis auf der DVD: Software zum Buch\Kap06\Fortran\. Die Datei Force209GFortranSetup.exe ist nur für Windows-Systeme gedacht. Fortran-Compiler für andere Betriebssysteme findet man im Internet, aber auch gute Anleitungen wie folgendes Tutorial: http://folk.uio.no/steikr/doc/f77/tutorial/. Nachdem Sie Fortran installiert haben, können Sie im Startmenü unter Force 2.0 die Fortran-Entwicklungsumgebung starten. Fortran ist keine Freiformat-Sprache, sondern spaltenorientiert. Wir kennen das inzwischen von Assembler, wo es im Quelltext eines Programms auch Spalten gibt. Dieser Editor nummeriert zunächst einmal die Zeilen selbstständig durch. Früher mussten das die Programmierer selbst machen. Die erste Spalte ist für sogenannte Labels. Damit kann man Zeilen mit Nummern versehen, die sich mit GOTO anspringen lassen. Außerdem kann man eine Zeile zu einer Kommentarzeile machen, wenn man in die erste Spalte ein ›c‹ schreibt. Setzt man in die letzte Position der ersten Spalte ein Pluszeichen, so gilt die Zeile als Teil der vorigen Zeile. Praktisch zeigt das folgendes Programm:

Abbildung 6.5

Fortran-Programm

Es wird allerdings nicht laufen, wenn wir es so abtippen oder von der DVD holen: Software zum Buch\Kap06\Fortran\magischezahlen.f. Ganz einfach weil es eine If-Abfrage auf int1 > 600 gibt. Und weil int1 größer als 600 ist, geht das Programm zur Zeile mit dem Label 100. Dort wird es beendet. Bei write (*,*) steht der erste Stern für den Kanal, der zweite für das Format. 244

Die Turingmaschine

Heute ist Fortran längst nicht mehr die einfache Sprache, die Backus entwickelt hatte. Die Sprache wurde nie aufgegeben, man hat sie ständig erweitert und weiterentwickelt. Die älteste Version, die man hier und dort noch findet, ist Fortran 77. Sie entspricht in etwa unserem Praxisbeispiel.

6.2

Die Turingmaschine

Alan Turing war der Meinung, dass man sich vor dem Bau eines Computers darüber im Klaren sein sollte, wozu er überhaupt fähig ist. Um das herauszufinden, erdachte er eine einfache Maschine, die genau das berechnen kann, was auch Menschen berechnen können – nicht mehr, aber auch nicht weniger. Seine Originalveröffentlichung vom 12. November 1936 kann man sich im Internet ansehen: http://www.wolframscience.com/prizes/tm23/images/Turing.pdf. Die Maschine sollte denkbar einfach sein und trotzdem alle bekannten Algorithmen lösen können. Turing stellte sich einen endlos langen Papierstreifen vor, der Felder für Zeichen oder Ziffern hatte. In ein Feld passte nur ein Zeichen, oder es blieb leer. Zusätzlich benötigte man noch Bleistift und Papier. Den denkbar simpelsten Computer kann man also jederzeit an einem Schreibtisch simulieren. Es geht aber auch etwas technischer, in Form einer Maschine, die aus einem programmgesteuerten Schreib-/Lesekopf besteht, und aus einem endlosen Band, dem Papierstreifen. Die Maschine kann das Band vor- oder zurückschieben, die Felder darauf lesen oder beschreiben, und sie kann anhalten. Das Witzige an dieser einfachen Konstruktion ist nun, dass sie nur mit ihren drei Funktionen – Lesen, Schreiben und das Band bewegen – alle Aufgaben lösen kann, die auch ein Computer löst. In der sogenannten Church-Turing-Hypothese wird sogar behauptet, dass der Mensch auch nicht mehr berechnen kann als ein solcher Apparat. Übrigens hat 2007 ein englischer Student bewiesen, dass die Zwei-ZustandsTuringmaschine von Stephen Wolfram eine universelle Turingmaschine ist, und er gewann damit einen Preis von 25.000 $ (http://www.heise.de/newsticker/meldung/97991). Seine Erfindung ist damit auch die einfachste universelle Turingmaschine. In der Tat lassen sich alle mathematischen Grundfunktionen wie Addition, Subtraktion und Multiplikation mit dieser Maschine und ihren zwei Zuständen simulieren. Die ganze Mathematik baut auf diesen Grundfunktionen auf, somit lässt sich durch weitere Simulationen alles berechnen, was berechenbar ist.

245

6.2

6

Von Lady Ada bis F#

Alan Turing Alan Turing entschlüsselte nicht nur den deutschen Geheimcode, er legte auch die theoretischen Grundlagen zum Bau der Computer. Ebenfalls von großer Bedeutung war hierbei die Arbeit eines weiteren mathematischen Vordenkers, nämlich von John von Neumann. Mit Alan Turing fing der Spaß am Computer so richtig an. Er erdachte sich nämlich unter anderem so tolle Dinge wie die Turingmaschine und den Turingtest.

Eine Funktion, die mit einer Turingmaschine berechnet werden kann, nennt man eine turingberechenbare Funktion. Es lässt sich also mit Recht sagen, dass die Turingmaschine eine Art grundlegender Computer ist. Allerdings gibt es auch einen Haken an der Sache. Gerade als David Hilbert und Bertrand Russell dabei waren, in der Principia Mathematica die gesamte Mathematik auf logischer Basis zu beweisen, gelang es dem jungen österreichischen Mathematiker Kurt Gödel zu belegen, dass ein solcher Beweis völlig unmöglich ist. In logischen Systemen gibt es immer unbeweisbare Sätze. Genau dieses Problem zeigt auch die Turingmaschine. Darüber hinaus belegt sie, dass es unmöglich ist, vorher zu beweisen, dass das aktuelle Problem eines der vielen lösbaren oder eines der unlösbaren Probleme ist.

6.2.1

Aufbau und Funktionsweise einer Turingmaschine

Eine Turingmaschine liest Zeichen und verändert diese. Sie ist damit die denkbar einfachste Form einer Datenverarbeitungsmaschine. Alan Turing erdachte diese Maschine 1936, um die Berechenbarkeit von Funktionen zu zeigen. Außerdem ist sie laut Turing ein Modell für die Vorgehensweise des rechnenden Menschen. Die Maschine besteht aus drei Teilen, einem Speicherband, das man sich als unendlich lang denkt, einem Schreib-/Lesekopf und der Steuereinheit. Das Band steht als Symbol für einen seriellen Speicheraufbau und die serielle Denkweise des Menschen. Es enthält Speicherstellen, die der Schreib-/Lesekopf nur einzeln lesen und überschreiben kann. Die Steuereinheit umfasst die Anweisungen zur Verarbeitung der Daten, das Programm. Im Programm sind gelesene Zeichen einfach nur zu schreibenden Zeichen gegenübergestellt. Das bedeutet, dass einer eingehenden Information immer eine ausgehende Information gegenübersteht, es steht auch immer fest, was als Nächstes gelesen wird oder ob der Endzustand erreicht ist. Apropos Zustand: Zusätzlich hat die Maschine auch noch einen festgelegten Zustand, der Teil des Programms ist. Das bedeutet, dass sie nicht nur vorgeschrieben bekommt, was sie als Nächstes zu lesen hat, sondern auch, wie sie darauf reagieren soll. Sie hat sozusagen drei Eigenschaften:

246

Die Turingmaschine

왘

zu lesende Information

왘

einstellbarer Zustand

왘

zu schreibende Information

Fast unglaublich ist die Tatsache, dass damit die gesamte EDV beschrieben wurde. Während Alan Turing seine Maschine noch auf dem Papier mit Bleistift und Radiergummi ablaufen ließ, sind wir heute in der glücklichen Lage, dieses Modell von einem Computer durchrechnen zu lassen. Das wollen wir auch gleich einmal tun, dadurch wird die Funktionsweise wesentlich anschaulicher. Eine in Java programmierte Turingmaschine befindet sich auf der beiliegenden DVD unter Software zum Buch\Kap06\Turingmaschinen\Software als Turing 001.jar. Ein Dialog wird geöffnet, der eine simulierte Turingmaschine zeigt.

Abbildung 6.6

Die Turingmaschine

Die Dialogbox der Simulation gliedert sich in drei Teile: die eigentliche Turingmaschine mit dem endlosen Band und dem Schreib-/Lesekopf. Dazu gehören die Bedienelemente, die zum Start und Anhalten (Pause), aber auch zum Zurück-

247

6.2

6

Von Lady Ada bis F#

setzen (Reset – was ganz wichtig ist) der Maschine dienen. Zusätzlich gibt es noch die Möglichkeit von Einzelschritten (Step). Im Eingabefeld (Input/Config) lassen sich Daten eingeben, die mit der Schaltfläche Load auf das Band übernommen werden sollen. Ist ein Programm geladen, müssen hiermit erst Daten aufs Band geschrieben werden, bevor man starten kann. Im Programmfeld wird das aktuell geladene Programm angezeigt, das mit der Schaltfläche Load in den Arbeitsspeicher der Turingmaschine übernommen werden kann. Die verfügbaren Programme zeigt die Combobox neben der Schaltfläche an. Die Programme befinden sich innerhalb der Turing001.jar-Datei in gepackter Form. Geben wir beispielsweise die binäre Zahl 1111111111 ins Eingabefeld ein, eben zwei Hände voll Einsen, die, wie wir wissen, die dezimale Zahl 1023 darstellen. Mit Load stellen wir die Zahl auf das Band. Im nächsten Schritt laden wir ein Programm, beispielsweise increment.tm, durch Auswahl in der Combobox und Anklicken der Load-Schaltfläche. Das Programm wird nun in der Programmtabelle angezeigt:

Abbildung 6.7

Das Programm, in der Turingmaschine geladen

Im Programm werden entsprechend dem gelesenen Zeichen das zu schreibende Zeichen, der Zustand und die Bewegung des Schreib-/Lesekopfes festgelegt. Nun

248

Die Turingmaschine

stellen wir die Geschwindigkeit etwas höher – den Speed-Schieber nach rechts schieben – und betätigen die Start-Schaltfläche. Die Turingmaschine bildet nun das sogenannte 2er-Increment. Wir stellen das nächste Beispiel einmal ganz übersichtlich in einer Tabelle dar. Die erste Zeile zeigt, welches Zeichen die Maschine gelesen hat. Hat sie beispielsweise ein Y gelesen, müssen wir in der dritten Spalte nachsehen. Außerdem müssen wir wissen, in welchem Zustand sich die Maschine gerade befindet. Wäre sie beispielsweise im Zustand 2, hieße das: Zeile Zustand 2 und ein Y gelesen als Y : 2 : R, was bedeutet: Sie schreibt ein Y, bleibt im Zustand 2 und bewegt den Schreib-/Lesekopf nach rechts. Gelesenes Zeichen

#

X

Y

Zustand 1

#:1:R

Y:2:R

Y:2:R

Zustand 2

#:2:H

Y:2:R

Y:2:R

Tabelle 6.1

Turingprogramm: Wandle alle X nach Y!

Legende :

Trennung der Anweisungsteile

Nummer des Zustandes

L

Kopf nach links bewegen

R

Kopf nach rechts bewegen

H

Maschine anhalten

#

Leerzeichen

alle verfügbaren Zeichen

Tabelle 6.2

Legende der Zeichen

Schauen Sie sich das Beispiel an. Auf dem Band sind aufeinanderfolgend die Zeichen Y und X gespeichert. ########YXYYXYYYXYXY###### ^ Die Maschine steht auf dem letzten Leerzeichen vor der Zeichenfolge. Sie liest also ein Leerzeichen, sobald sie in Betrieb genommen wird. Nach dem Programm besagt dies, dass sie ein Leerzeichen schreibt, im ersten Zustand bleibt und sich nach rechts bewegt. Sie liest also ein Y, schreibt ein Y, fällt in den zweiten Zustand und bewegt sich weiter nach rechts. Sie liest ein X, schreibt ein Y, bleibt im zweiten Zustand und geht nach rechts. So geht es weiter, bis sie auf ein Leer-

249

6.2

6

Von Lady Ada bis F#

zeichen trifft und demzufolge im zweiten Zustand anhält. Das ist doch keine Hexerei, werden Sie denken. Nun gehen wir daran, die Maschine über ein selbstgeschriebenes Programm laufen zu lassen. Wer es sich nicht zutraut, kann gerne noch ein wenig mit der Turingmaschine experimentieren und den folgenden Abschnitt überspringen. Wer es sich aber zutraut, sollte sich als Turing-Programmierer versuchen. Praxis: Die Programmierung einer Turingmaschine Für alle, die es nun genauer wissen wollen, folgt ein kleiner Kurs zur Programmierung einer Turingmaschine. Es geht nicht darum, in Java ein Programm zu schreiben, das eine Turingmaschine zeigt, sondern die Maschine selbst zu programmieren. In diesem ganz einfachen Programm soll ein doppelt vorkommendes Zeichen gefunden werden. Wenn also ein X doppelt vorkommt, soll die Maschine genau dort stehen bleiben. X muss praktisch gezählt werden, also sollte die Maschine nach dem Lesen eines X in den zweiten Zustand fallen. In ihm kann sie bei Vorkommen eines weiteren X stehen bleiben. Vorher sollte sie noch einen Schritt zurückgehen, also auf das erste X. Bei allen anderen Zeichen kann sie im ersten Zustand bleiben und Zeichen für Zeichen so ausgeben, wie sie es liest. Nach diesen Überlegungen ist es einfach, eine entsprechende Tabelle zusammenzustellen. Das sollte man auch zum Schreiben eines Programms tun, und zwar auf Papier. Die Lösung sollte aussehen wie Tabelle 3: Finde das Doppel-X. Gelesenes Zeichen

#

X

Y

Z

0

# :0 :R

X :1 :R

Y :0 :R

Z :0 :R

1

# :0 :R

X :H :L

Y :0 :R

Z :0 :R

Tabelle 6.3

Finde das Doppel-X!

Nun benötigen wir eine Version der Turingmaschine, die in der Lage ist, Programme von der Festplatte einzulesen. Eine derartige in Java programmierte Turingmaschine befindet sich auf der beiliegenden DVD unter Software zum Buch\Kap06\Turingmaschinen\Software als Turing002.jar. Nun erstellt man eine Textdatei mit dem Programm Start-Icon 폷 Alle Programme 폷 Zubehör 폷 Editor. In der ersten Zeile gibt man den Namen des Programms als Kommentar ein: # Suche das Doppel-X

250

Die Turingmaschine

Jetzt folgt die Zeile des Programms. Das Programm will sie etwas anders präsentiert haben. Zum Beispiel wird mit Zustand 99 die Maschine angehalten. Den Rest zeigt die folgende Tabelle: Zustand

Lesen

Schreiben

Bewegung

Nächster Zustand

0

x

x

r

1

0

y

y

r

0

0

z

z

r

0

0

*

*

r

0

1

x

x

n

99

1

y

y

r

0

1

z

z

r

0

1

*

*

r

0

Tabelle 6.4

Programm

Das fertige Programm wird also so aussehen: # 0 0 0 0 1 1 1 1

Suche x x r y y r z z r * * r x x n y y r z z r * * r

das Doppel-X 1 0 0 0 99 0 0 0

Das ist schon alles. Nun kann man das Programm mit Datei 폷 Speichern auf die Festplatte speichern, und zwar genau in dem Verzeichnis, in dem die Turingmaschine gespeichert ist. Der Dateiname sollte mit der Endung .tm versehen werden, dadurch sieht man direkt, dass es sich um ein Programm für eine Turingmaschine handelt. Nach dem Start von Turing002 können Sie mit Load das Programm auswählen, das Band z. B. mit zxyzzyyxxyz füllen und mit Start ablaufen lassen. Wichtig ist auch, die Geschwindigkeit nicht zu langsam einzustellen, sonst bleibt die Maschine stehen. Nach jedem Versuch sollte Reset betätigt werden. Ein Problem enthält das Doppel-X-Programm natürlich noch: Wenn die Maschine kein doppeltes X trifft, läuft sie endlos weiter.

251

6.2

6

Von Lady Ada bis F#

Eine Turingmaschine führt nur einfachste Operationen aus, daher ist es gar nicht einfach, ein Programm für sie zu schreiben. Sie können sich gerne Gedanken zu weiteren Programmen machen, so werden Sie diesen Sachverhalt erkennen. Relativ einfach sind Addierer oder Zählwerke. Je einfacher also eine Maschine ist, desto länger und komplizierter werden die Programme, die man für sie schreiben muss. Auf der DVD finden Sie einige weitere Turingprogramme, die zum Experimentieren einladen sollen, und zwar ebenfalls unter: Software zum Buch\Kap06\Turingmaschinen\TuringProgramme. Hier befinden sich einfache Addierer und Zählwerke, aber auch Programme, die man scherzhaft als fleißige Biber bezeichnet. In der Datei steht jeweils, welche Eingabe gemacht werden kann. Selbst wenn Sie keine eigenen Programme schreiben möchten, so können Sie diese doch mit der Turing002.jar starten und sich anschauen, wie sie abgearbeitet werden.

6.2.2

Fleißige Biber und die Unvollständigkeit der Mathematik

So einfach die Turingmaschine auch wirken mag, so tiefgründig sind die Überlegungen, zu denen sie Mathematiker bereits angeregt hat. Eine dieser Ideen ist, möglichst viele Einsen auf das endlose Band zu schreiben, wonach das Band auch anhält. Schließlich ist es trivial, ein Programm zu schreiben, das endlos Einsen erzeugt. Gelesenes Zeichen

#

0

1

0

1 :0 :R

1 :0 :R

1 :0 :R

Die Frage ist, wie lange kann eine Maschine mit möglichst wenigen Anweisungen laufen, ohne dass sie ziellos weiterläuft? Turingmaschinen, die möglichst viele Zeichen schreiben, bevor sie stehen bleiben, nennt man fleißige Biber. 1962 hat der ungarische Mathematiker Tibor Radó eine Funktion entwickelt, die angibt, wie viele Einsen ein fleißiger Biber bei einer bestimmen Anzahl an Zuständen höchstens schreiben kann. Man nennt sie Radó- oder Fleißiger-BiberFunktion. Praxis: Biberjagd Das eigentliche Problem besteht darin, dass sich nicht genau bestimmen lässt, wie viele Einsen ein Biber mit einer bestimmten Anzahl an Zuständen erzeugen

252

Die Turingmaschine

kann. Bei ganz einfachen Bibern, mit weniger als fünf Zuständen, kann man das durchaus noch. Ab fünf Zuständen gibt es jedoch so viele Möglichkeiten für Turingmaschinen, dass sie nicht mehr bestimmbar sind. Es ist nicht einmal mehr berechenbar, wann der Biber fertig ist. Man müsste also alle Fünferbiber durchtesten, um das festzustellen. Fangen wir mit einem Einerbiber an. Das ist ein Biber, der nur einen Zustand hat. Er wird folglich auch nur ein Zeichen schreiben können. Wie sollte er anhalten? 0 0

* 1

1 1

L L

99 99

So sieht ein Programm für den Einerbiber aus. Der Zweierbiber kann immerhin schon drei Einsen schreiben. Der Biber liegt im Verzeichnis Software zum Buch\ Kap06\Turingmaschinen\TuringProgramme\2erBiber.tm. auf der DVD. Versuchen Sie es. Starten Sie Turing002.jar, und laden Sie das Programm 2erBiber.tm. Jetzt muss nur noch das Band vorbereitet werden, am besten mit ******** , einer Reihe Leerzeichen, alles löschen. Nun können Sie mit der StartSchaltfläche den Biber starten. Richtig interessant wird es aber erst mit Fünfer- und Sechserbibern. Das sind Turingmaschinen, die Billionen Schritte ausführen, bis sie anhalten. Es gibt regelrechte Biberjäger, die nach solchen Bibern suchen. Auch hier gilt es noch, mathematische Beweise zu erbringen und Lorbeeren zu ernten. Einer der bekanntesten und erfolgreichsten Biberjäger ist Heiner Marxen: http://www.drb.insel.de/ ~heiner.

6.2.3

Vollständig unvollständig

In diesem Zusammenhang fällt oft der Begriff der Gödelschen Unvollständigkeit. Hierauf wollen wir angesichts unserer schönen Beispiele noch etwas genauer eingehen. Laut dieser Unvollständigkeit ist es nämlich gar nicht möglich zu beweisen, nach wie vielen Schritten ein Biber fertig ist. Was ist turingvollständig? Den Ausdruck turingvollständig, den man öfter liest, wenn man sich mit der theoretischen Informatik oder gar der KI auseinandersetzt, wollen wir hinterfragen. Ein Computer wäre turingvollständig, wenn er alles berechnen kann, was auch eine Turingmaschine berechnen kann. Das Gleiche lässt sich beispielsweise auch über Programmiersprachen sagen. Aber was ist eigentlich alles berechenbar? Genau genommen, eigentlich sehr wenig. Alles, was sich berechnen lässt, lässt sich auch mit einfachen Mitteln berechnen, wie die Turingmaschine beweist.

253

6.2

6

Von Lady Ada bis F#

In diesem Zusammenhang gibt es eine weitere Behauptung, die Church-TuringHypothese. Diese besagt: »Die turingberechenbaren Funktionen entsprechen genau den intuitiv berechenbaren Funktionen.« Das heißt, alles, was ein Mensch ausrechnen kann, kann auch eine Turingmaschine ausrechnen. Die Hypothese ist außer nach Alan Turing auch nach einem gewissen Alonzo Church benannt, der sie verfeinert hat. Es ist wirklich eine reine Hypothese. Die Menge der intuitiv berechenbaren Funktionen wird sich nie bestimmen lassen, daher kann man diese Hypothese auch nicht beweisen. Ist diese Aussage jedoch richtig, hat sie die gravierendsten Auswirkungen auf die Computerentwicklung. Sie besagt nichts anderes, als dass der erste Computer vom Prinzip her schon alles konnte, was der leistungsfähigste Rechner je können wird. Man kann es ganz krass sagen: Wenn es nicht möglich ist, der Turingmaschine das Denken beizubringen, wird das auch bei keinem mechanischen Gerät gelingen. Das Gravierendste dabei ist: Der Mensch wird auch seine Denkweise selbst nie bewusst erfassen können, und eine Maschine kann das natürlich auch nicht. Aber keine Angst, wir werden nicht versuchen, der Turingmaschine Bewusstsein einzuhauchen. Bei dem Versuch, andere Rechensysteme und Rechnermodelle zu konstruieren, die mehr leisten konnten als der Turing-Algorithmus, wurde die Church-TuringHypothese entdeckt. Der Versuch gelang jedoch nicht. Egal, was man auch berechnete, es zeigte sich immer wieder, dass die Turingmaschine das ebenfalls konnte. So wurde die Turingmaschine zum grundlegenden Formalismus der Berechenbarkeit. Nimmt man die Church-Turing-Hypothese als richtig an, kann man einerseits beweisen, dass eine Funktion nicht berechenbar ist, andererseits bedeutet das aber auch, dass alles, was von unseren heutigen Computern nicht berechnet werden kann, auch von künftigen Computergenerationen nicht geschafft wird. Zur Verbesserung von Rechnern bleibt uns im Grunde nur noch, deren Taktgeschwindigkeit zu erhöhen, mehr nicht – was fleißig von Intel und AMD gemacht wird. Der Unvollständigkeitsleitsatz von Gödel und die Auswirkung auf die Informatik Wir sprachen es bereits an. Gödel hat nachgewiesen, dass man in einem formalen System nicht jede Aussage logisch beweisen kann. Das bedeutet für unsere BiberTuringmaschine, dass sie auf der Suche nach einer bestimmten Lösung endlos weiterlaufen könnte, weil sie kein Ergebnis findet. Man bezeichnet diesen Sachverhalt als sogenanntes Halteproblem. Die Frage bei Unvollständigkeitstheorem und Halteproblem: Gibt es eine Möglichkeit zu entscheiden, ob eine vorliegende Aussage bewiesen werden kann oder nicht? Bei der Turingmaschine demnach: Gibt es eine Turingmaschine, die für eine bestimmte Turingmaschine, z. B. einen 254

ALGOL und die GOTO-Programmierung

Biber, bestimmen kann, wann diese fertig wird? Natürlich hat Alan Turing bereits 1936 diese Fragestellung beantwortet, indem er bewies, dass es keine Turingmaschine gibt, die das Halteproblem für alle Eingaben bestimmen kann. Auf der DVD befinden sich auch einige Beispiele für die fleißigen Biber. Sie zeigen recht anschaulich, worum es bei diesen Programmen geht (Software zum Buch\Kap06\Turingmaschinen\Turing-Programme). So zum Beispiel ein Programm, das Kopierbiber heißt. Die Programme werden auch mit Turing002.jar ausgeführt. Noch einmal soll unterstrichen werden, um welche theoretischen Überlegungen es bei solchen Programmen geht: Es ist nicht möglich, ein Programm zu schreiben, das aussagt, wie viele Schritte ein Biber mit einer bestimmten Zahl (n) an Zuständen laufen kann. Für kleine n ist das zwar noch möglich, aber bei einer Turingmaschine mit fünf Zuständen ist das bis jetzt noch nicht gelungen. Man muss nämlich dabei alle Biber mit fünf Zuständen betrachten. Weil die Anzahl der möglichen Biber mit fünf Zuständen jedoch immens ist, lässt sich das bereits mit n=5 schon nicht mehr verwirklichen. Diese Erweiterung der Turingmaschine führt zum sogenannten GOTO-Programm oder, wenn Sie so wollen, zur GOTO-Programmiersprache. Diese heißt aber nur so, weil ein zentraler Befehl in ihr GOTO heißt, was im Prinzip heißt: »Gehe zu«. Es fehlt dabei natürlich noch die Zieladresse, die angibt, wo der Programmfluss weiterlaufen soll. In der Geschichte der Programmiersprachen kommt keine Programmiersprache mit diesem Namen vor. Die erste erwähnenswerte GOTO-Programmiersprache erhielt den Namen ALGOL. »Zwei Zeilen genügen, um die Befähigung zum Softwaretester festzustellen. Welcher der beiden Sätze ist falsch? ›Der nächste Satz ist falsch.‹ ›Der vorige Satz ist wahr.‹«

6.3


Bevor wir uns ALGOL ansehen, werfen wir einen kurzen Blick auf die allgemeine GOTO-Programmierung. Sie ist, wie die Turingmaschine, relativ einfach aufgebaut. Die Zeilen bestehen grundsätzlich aus einer Marke. Wir werden dafür eine Zeilennummer verwenden, einen Doppelpunkt, die Anweisung und das Anweisungsende mit Semikolon. Also etwa so: Marke: Anweisung;

oder auch: Marke: Anweisung; Marke: Anweisung;

255

6.3

6

Von Lady Ada bis F#

Es gibt Variablen und Literale (also direkte Werte wie 1, 2, 3 ... »Text«) in begrenzter Anzahl und fünf Arten von Anweisungen: 1. Die Erhöhung eines Wertes: 100: x1 = x1 + 2;

2. Die Reduzierung eines Wertes: 101: xl = xl – 2;

3. Die Sprunganweisung: 103: GOTO 101;

4. Der bedingte Sprung: 104: IF x1 = 2 THEN GOTO 102;

5. Das Programmende: STOP;

Wer sich schon in der Programmierung ein wenig auskennt, sieht sofort, dass es hier um eine Sprache geht, die BASIC ziemlich ähnlich sieht. Das Witzige ist, dass sich nun einerseits beweisen lässt, dass ein GOTO-Programm genau das kann, was eine Turingmaschine kann, und andererseits, dass man alle denkbaren Programme aller üblichen Programmiersprachen in ein GOTO-Programm umschreiben kann. Oft gibt es in der Programmiersprache GOTO noch eine Unterscheidung zwischen der Zuweisung (:=) und dem Vergleich (=). Das wollen wir jedoch ignorieren. Praxis I: Ein einfaches GOTO-Programm Um ein einfaches GOTO-Programm schreiben zu können, wird eine Programmiersprache in Form eines Compilers oder Interpreters benötigt. Machen wir einen ersten Versuch mit ALGOL 68. Auch wenn die Sprache längst totgesagt ist, Entwicklertools gibt es immer noch für sie. Man findet sie unter http://sourceforge.net/projects/algol68/. Allerdings muss noch erwähnt werden, dass sich ALGOL und ALGOL 68 sehr unterscheiden. ALGOL 68 ist keineswegs eine Weiterentwicklung von ALGOL, sondern eigentlich eine Neuentwicklung. Ein ganz einfaches ALGOL 68-Programm in der »Hallo Welt«-Manier sehen Sie hier: COMMENT HALLO WELT PROGRAMM IN ALGOL 68

256


COMMENT BEGIN print("'MEHR CODING FOR FUN'") END

Äußerst praktisch ist es, den Interpreter vor dem Interpretieren umzutaufen, weil er einen recht langen Namen hat. Also aus a68g-1-18-0.exe per ren-Befehl a68.exe zu machen. Jetzt kann man das erste Programm mit folgender Befehlszeile starten: a68 .\demo\hallo.a68

Wem das Programm viel zu einfach ist, der kann sich an einem bekannten mathematischen Experiment versuchen, den sogenannten »Türmen von Hanoi«. Praxis II: Die Türme von Hanoi Entwickelt hat dieses Beispiel der französische Mathematiker Edouard Lucas (1842–1891), der zahlreiche spielerische Matherätsel entwickelte. Ein versteckt liegender Tempel im Urwald vor Hanoi war berühmt aufgrund seines geheimnisvollen Rätsels. Vor dem Tempeltor standen drei goldene Säulen. Auf einer dieser Säulen waren 100 Scheiben mit abnehmendem Durchmesser gestapelt, so dass immer eine kleinere auf einer größeren Scheibe lag. Tempelpriester, die dem Tempel für immer den Rücken kehren wollten, wurde diese Aufgabe gestellt. Der Scheibenturm ist unter folgenden Bedingungen auf eine der anderen Säulen umzustapeln: Die Scheiben dürfen nur einzeln von einer Säule zur nächsten transportiert werden. Es darf niemals eine größere auf eine kleinere Scheibe gelegt werden. Wie man zu wissen glaubte, lagen die Scheiben vom Tempelbau an bis heute immer auf der Säule ganz links. Warum das so war, könnten wir mit dem Programm untersuchen. Es ist ein rekursives Programm, also eins, das sich selbst immer wieder aufruft. COMMENT TUERME VON HANOI IN ALGOL 68 REKURSIVE LOESUNG COMMENT BEGIN PROC setze = (INT n, von, zu, ueber) VOID:

257

6.3

6

Von Lady Ada bis F#

IF n > 0 THEN setze(n - 1, von, ueber, zu); printf(($"Bewege obere Scheibe von Saeule "g" zu Saeule "gl$, von, zu)); setze(n - 1, ueber, zu, von) FI ; main: ( BEGIN setze(5, 1,2,3) END ) END

Das Programm liegt natürlich auch auf der DVD und kann über folgende Zeile gestartet werden: a68 .\demo\tuerme.a68

Betrachten wir das Problem rein mathematisch. Es gilt für die Anzahl n > 0 Scheiben eine Anzahl an Bewegungen: B = 2n – 1 Bei 100 Scheiben erhält man: 2100 – 1 = 1.267650 · 1030 = 1.267650E30 Wenn man davon ausgeht, dass der Mönch jede Sekunde eine Scheibe bewegt, so benötigt er nur 41.213.151.536.758.394.503.508 Jahre, um den Scheibenturm von der Ausgangssäule auf die Zielsäule umzuschichten. Edouard Lucas, der noch viele andere mathematische Rätsel entwickelte, starb auf ganz unglückliche Weise. Beim Bankett der französischen mathematischen Gesellschaft fiel einem Kellner Geschirr herunter, und ein zerbrochener Teller ritzte Lucas an der Wange. Er starb wenige Tage darauf an einer Blutvergiftung.

6.3.1

Compiler und Interpreter

Mit der Entwicklung interaktiver Betriebssysteme kam auch eine neue Art des Programmierens auf. Hatte man beim Batchbetrieb Programme an einem Stück geschrieben und übersetzen lassen, also kompiliert, so bestand mit den interaktiven Systemen die Möglichkeit, dem Nutzer sofort zu sagen, wenn er einen Fehler eingetippt hatte. Weil das nach jedem Buchstaben nicht sinnvoll ist, wird ein solcher Testlauf erst nach einer vollständigen Programmzeile ausgeführt. Der Rech-

258


ner interpretiert die Zeile, indem er sie versuchsweise ausführt. Ein Programm, mit dem man interaktiv programmieren kann, nennt man Interpreter.

6.3.2

BASIC

Wir wollen uns einen Interpreter mit der Sprache ansehen, die am häufigsten für Interpreter genutzt wurde. Sie entstand allerdings erst 1964, über ein halbes Jahrzehnt nach ALGOL, und nennt sich BASIC. Die Entwickler der Sprache waren John George Kemeny und Thomas Eugene Kurtz vom Dartmouth College. Ihre Idee dabei war, Elektrotechnik-Studenten den Einstieg in die Programmierung zu erleichtern. Sie taten sich mit ALGOL und Fortran recht schwer. Um anderen Schulen den Einsatz von BASIC ebenfalls möglich zu machen, gaben die Entwickler die Sprache an Schulen kostenlos ab. Zahlreiche Hardwarehersteller entwickelten Interpreter für diese Sprache, da es schon etliche BASIC-Kenner gab und weil man die Sprache schnell erlernen konnte. Auch Microsoft bot einen BASIC-Interpreter an, noch bevor es sein erstes Betriebssystem verkaufte. Praxis: bwBASIC Zu den ersten DOS-Versionen gehörte auch bwBASIC, ein BASIC-Interpreter. Einen solchen Interpreter wollen wir nun nutzen, und zwar eine Nachprogrammierung dieses ersten Interpreters. Richten Sie sich einen virtuellen Rechner mit Ubuntu-Linux ein, oder nutzen Sie einen bereits installierten. bwBASIC kann ganz einfach mit der System 폷 Systemverwaltung 폷 Synaptic Paketverwaltung in Ubuntu nachinstalliert werden. Am schnellsten kommt man zum Ziel, wenn man rechts über Suche direkt nach bwBasic sucht. bwBASIC steht für Bywater BASIC, ein Augenzwinkern in Richtung gwBASIC, eine der häufigsten BASIC-Versionen von Microsoft aus der guten alten DOSZeit.

Wie bereits bei der Installation zu sehen ist (siehe Abbildung 6.8), handelt es sich dabei um einen BASIC-Interpreter mit einem minimalen Sprachumfang nach dem Standard X3.60 von 1978. Dies ist ein Interpreter, in dem direkt Codezeilen (interaktiv) eingegeben werden können. Er führt aber auch Programme aus, die als Datei abgelegt sind, und zwar beim Aufruf in dieser Form: bwbasic datei.bas

259

6.3

6

Von Lady Ada bis F#

Abbildung 6.8

Die Installation von Bywater BASIC

Beginnen wir mit einem ganz einfachen Programm. Hierzu starten Sie zunächst bwBASIC mit bwbasic . Der Interpreter startet im interaktiven Modus und zeigt eine Eingabezeile in dieser Form (siehe Abbildung 6.9): bwBASIC: _

Abbildung 6.9

260

Der Interpreter läuft und wartet auf Befehle.


Der Interpreter läuft und erwartet die Befehle, zumindest solche, mit denen er etwas anzufangen weiß. Davon gibt es einige, wie z. B.: 왘

CLEAR: Bildschirm clearen

왘

QUIT: Interpreter beenden

왘

RUN: aktuelles Programm starten

Nun tippen Sie das Programm zeilenweise ein, die Zeilennummer zuerst. Nach jedem (¢) erscheint wieder der bwBASIC-Prompt. 왘

bwBASIC: 10 REM Unser erstes bwBASIC-Programm

왘

bwBASIC: 20 PRINT "Hallo und guten Tag mit mehr Coding for Fun"

Wie sich erkennen lässt, gibt es die Möglichkeit, mit REM einen Kommentar einzugeben, der unabhängig vom auszuführenden Code ist. Sobald eine Zahl und hinter dem folgenden Leerzeichen etwas eingegeben wird, erkennt bwBASIC das als Programmzeile. Es wird in Zehnerschritten nummeriert. Die Zeilen lassen sich schlecht verschieben, daher kann man bei Zehnerschritten später immer noch Zeilen einfügen. Gibt man eine Zeilennummer an, die bereits existiert, wird diese Zeile überschrieben. PRINT gibt ein Stringliteral oder den Inhalt von Variablen am Bildschirm aus. LIST zeigt die Zeilen an, die man bis zu diesem Zeitpunkt getippt hat, und mit RUN werden sie ausgeführt. Nur eine einfache Begrüßung genügt uns aber nicht. Wir wollen ein paar Informationen mehr. 왘

30 PRINT "Wir haben den " + DATE$

왘

40 PRINT "Um " + TIME$ + " Uhr"

Wenn Sie nun RUN eingeben, fällt die Begrüßung umfangreicher aus.

Abbildung 6.10

Begrüßung mit Uhrzeit

261

6.3

6

Von Lady Ada bis F#

Beendet wird mit bwBASIC: quit

6.3.3

ALGOL

Bereits 1958 begann mit der ersten ALGOL-Version die neue Epoche der anwendungsorientierten Programmiersprachen. Deshalb fällt der Name ALGOL auch öfter, als man es von einer im Grunde toten Sprache erwartet. Schließlich war sie nicht die erste höhere Programmiersprache. Aber sie brachte einige revolutionäre Konzepte mit: 왘

Sie hatte als erste prozedurale Sprache die Möglichkeit der rekursiven Aufrufe. Das heißt nichts anderes, als dass sich ein Unterprogramm bedarfsweise selbst aufruft. Wie das geht, haben wir bereits am Programm »Die Türme von Hanoi« gesehen.

왘

Um das zu können, musste sie die Möglichkeit haben, Teilprogramme, sogenannte Unterprogramme zu bilden. Dazu musste man Codezeilen gruppieren können. Hier spricht man von Blöcken.

왘

Dies wiederum setzte die Festlegung der Variablengültigkeit voraus. Eine Variable ist nur in dem Block bekannt, in dem sie deklariert wurde, und in den Unterblöcken dieses Blocks.

왘

Blöcke können demnach verschachtelt werden.

왘

Unterprogramme unterscheidet man in Funktionen mit Rückgabe von Werten und Prozeduren ohne Wertrückgabe.

왘

Unterprogramme können Werte vom aufrufenden Programm übernehmen. Man spricht von Parameterübergabe.

왘

Parameter können auf verschiedene Weise übergeben werden. Entweder: 왘

Call by Value Dies bedeutet, dass nur der Inhalt einer Variablen an ein Teilprogramm weitergegeben wird. Er wird darin sozusagen in einer neuen Variablen aufgenommen. Wird das Teilprogramm beendet, verliert der Wert seine Bedeutung, die ursprüngliche Variable erfährt davon nichts. Oder:

왘

Call by Name Beim Beenden des Teilprogramms wird die Variable mit dem aktuellen Wert aus dem Teilprogramm befüllt. Das ist so, als wäre die Variable im Teilprogramm weiter genutzt worden.

Alle diese Neuerungen brachten Erleichterungen für den Programmierer. Sie waren aber auch problematisch, was die Erstellung der lauffähigen Programme

262


anging. Wenn man ein Teilprogramm hat, das irgendwo im Hauptprogramm aufgerufen wird – womöglich noch mehrmals –, so kannte man die Adresse dieses Teilprogramms erst, wenn man es in das Hauptprogramm einbaute. Aufrufe, die zuvor erfolgten, kannten keinerlei Aufrufziel. Deshalb konnten die Compiler das binäre Programm gar nicht fertigstellen. Wenn alle Teilprogramme fertig übersetzt waren, musste man sich die Sprungadressen und die Rücksprungadressen ausrechnen, an der richtigen Stelle einsetzen und alle Teilprogramme zusammensetzen. Diesen Vorgang nannte man linken (binden) und das entsprechende Programm Linker. Man unterscheidet statisches und dynamisches Linken. Beim statischen werden die Programmteile, so wie sie sich aufrufen, fest zusammengefügt, und es wird eine einzige Datei erzeugt. Jahre später, als die Programme komplexer wurden und man viele Teilroutinen benötigte, um z. B. wie bei Windows Fenster aufzubauen, setzte sich das dynamische Linken durch, bei dem die Teilprogramme in eigenen Dateien liegen und je nach Bedarf aus diesen Dateien aufgerufen werden. Unter Windows haben diese Dateien die Endung .dll, was für Dynamic Link Library steht. Wegen der hohen Komplexität der Software begann man mehr und mehr, Hilfsmittel bei der Erstellung zu nutzen. Eines davon nennt sich Make. Zu jedem Programmcode gehört dabei eine Datei makefile, in der beschrieben ist, wie der Code übersetzt werden soll. Bei großen Projekten wird makefile auch nicht mehr von Hand erstellt, sondern mit Hilfe von Programmen generiert. Einige dieser Hilfsprogramme sind: autoconf, automake und mkmf oder qmake. Praxis In einer Make-Datei wird ausgehend vom Zielprodukt der zu erzeugenden lauffähigen Datei beschrieben, wie Compiler und Linker zu arbeiten haben. Die Beschreibung ist dabei so aufgebaut, dass der Name einer Zieldatei genannt ist und jeweils darunter, wie die Datei zu erstellen ist. Prinzipiell ist eine Make-Datei etwa so aufgebaut: CC = Compiler.exe L = Linker.exe Zielprogramm: Teil1.o Teil2.o Teil3.o $(L) -o Zielprogramm Teil1.o Teil2.o Teil3.o Teil1.o: Teil1.c $(CC) -c Teil1.c

263

6.3

6

Von Lady Ada bis F#

Zunächst einmal werden Abkürzungen für die genutzten Produkte festgelegt, damit man die Namen nicht immer ausschreiben muss. Jetzt wird beschrieben, dass das Zielprogramm aus drei Objektdateien zusammengelinkt werden muss. Darunter steht nun noch, dass die erste Objektdatei aus der C-Datei compiliert werden soll. Schauen wir uns das Ganze einmal an. Dazu nutzen wir eine FreeDOS-Installation auf einem virtuellen Rechner. FreeDOS bringt gleich eine ganze Entwicklungsumgebung mit. Dazu gehören die Compiler und Linker, aber auch die Make-Dateien. Dieser C-Compiler nennt sich WATCOM, er war seinerzeit einer der technisch herausragendsten Softwareentwicklungs-Werkzeuge. Auch wenn man kein Informatiker oder Programmierer ist, kann man sich damit sehr schön ansehen, wie so etwas damals ablief. Hat man FreeDOS noch nicht installiert, kann man das mit wenigen Schritten auf einem virtuellen Rechner tun. Man hängt die FreeDOS-ISO-Datei als Massenspeicher-Medium in die Virtual Box ein (rechts Massenspeicher anklicken). Die ISO-Datei liegt unter Software zum Buch\Kap06\FreeDOS\fdfullcd.iso. Zum Booten muss man eventuell die CD als Bootmedium im BIOS (F12) angeben. Nach der Installation kann man das Medium wieder aushängen und sich als C-Entwickler versuchen. Wechseln Sie zunächst in das WATCOM-Verzeichnis: cd fdos\watcom

Wenn Sie sich dort mit dir umsehen, finden Sie eine Datei setvars.bat, mit der Sie die Variablen für die Entwicklungsumgebung setzen können. setvars

Nun wechseln Sie in das Verzeichnis mit dem Beispielcode: cd samples\goodies

Auch hier informiert uns ein dir darüber, wie es in dem Verzeichnis aussieht. dir /p

Es gibt eine ganze Reihe von C-Quellcode-Dateien, die als Endung .c haben und eine makefile-Datei. Diese enthält die Anleitungen für das make-Programm zum Bau der lauffähigen Software aus den C-Dateien. Beim WATCOM-Compiler heißt das make-Tool übrigens »wmake«. Wen es interessiert, der kann vor dem Start von wmake noch in die eine oder andere Datei sehen. Das geht unter FreeDOS

264


ganz einfach mit dem edit-Befehl, gefolgt von dem Namen der Datei, zum Beispiel: edit MAKEFILE

Wenn es losgehen kann, tippt man einfach nur: wmake

Wie beim Kompilieren gibt es eventuell Fehlermeldungen. Für den Entwickler heißt das: Fehler lokalisieren und makefile anpassen. Wir machen uns das einfacher. Die ersten Fehler beziehen sich auf Dateinamen, die mit f beginnen müssen und auf Dateien verweisen, die es gar nicht gibt. Wir kopieren einfach die erforderlichen Dateien aus den Dateien ohne f, z. B.: copy handles.c fhandles.c

oder copy memory.c fmemory.c

Sollte uns dagegen Bimodal.c Schwierigkeiten machen, kommentieren wir alle Zeilen, die sich in makefile auf Bimodal und Co. beziehen, einfach aus. Das geht mit dem #-Zeichen: #

bimodal.exe &

Dazwischen kann man jederzeit nochmals wmake aufrufen (siehe Abbildung 6.11). Das Make-Tool kontrolliert genau, was schon erzeugt wurde und was es noch zu erzeugen hat. Schaut man sich mit dir /p den Inhalt des Verzeichnisses an, wird man feststellen, dass sowohl obj- als auch exe-Dateien erzeugt worden sind. Die exe-Dateien können wir natürlich starten, um zu sehen, was wir kompiliert haben. Es sind verschiedene Hilfsprogramme, die Informationen zum DOS ausgeben. Sollte beim Aufruf eines Programms allerdings die Meldung kommen This is a DOS/4G executable

handelt es sich hierbei um ein Programm, das zur Ausführung DOS/4G benötigt. Damit kann ein DOS-Programm bis zu 64 MB Arbeitsspeicher nutzen statt der obligatorischen 640 KB. Zum Starten muss man allerdings das Programm dos4gw verwenden, z. B. so: dos4gw fmemory

265

6.3

6

Von Lady Ada bis F#

Abbildung 6.11

wmake verteilt die Arbeit auf Compiler und Linker.

6.4

Mehr Sprachen, bitte!

6.4.1

Cobol und PL/1

Fortran und ALGOL waren, wenn man so will, Sprachen, die besonders gut zur Programmierung wissenschaftlicher und technischer Aufgaben geeignet sind. Was nicht weiter verwundert, weil auch Techniker Computer entwickeln und bei ihrer Entwicklungsarbeit viel zu Rechnen haben. Das größte Einsatzfeld des Computers war freilich auch damals schon Verwaltung und Finanzwesen. Ein gutes betriebswirtschaftliches Programm mit Fortran oder ALGOL zu schreiben, ist jedoch fast ein Ding der Unmöglichkeit. Es war also nur eine Frage der Zeit, wann eine neue Sprache kommen musste. Federführend war jedoch keine Großbank, sondern das Pentagon, das ebenfalls eine Sprache für Verwaltungsaufgaben brauchte, jedoch eine Universalsprache suchte. Mehrere Ausschüsse wurden gegründet. Man kam jedoch 1959 zu der Erkenntnis, dass es bereits eine Sprache gab, die den Anforderungen fast vollständig gerecht wurde. Sie nannte sich FLOW-MATIC und war die Schöpfung der uns bereits bekannten Grace Hopper, die deshalb auch oft als »die Mutter von COBOL« bezeichnet wird. Man standardisierte also die »neue« Sprache und nannte sie COBOL als Abkürzung von Common Business Oriented Language, was auf Deutsch »allgemeine kommerziell orientierte Sprache« heißt.

266


Seit ihrer Entstehung wurde die Sprache ständig weiterentwickelt, ohne dabei ihre Grundstruktur zu verlieren – das ist ihre strenge Gliederung, die ausschließliche Nutzung von Großbuchstaben und ihre Orientierung an der englischen Sprache. Die zahllosen Versionen werden über die nachgestellten Jahreszahlen unterschieden. Es gibt inzwischen sogar eine Version für Microsoft.NET. Neben den aktuellen Kaufversionen existiert auch eine freie COBOL-Version. Sie heißt OpenCOBOL, ist jedoch kein echter COBOL-Compiler, sondern ein Transpiler oder auch Transcompiler. Er übersetzt den COBOL-Quellcode in CQuellcode, den man mit einem C-Entwicklungssystem in ein lauffähiges Programm übersetzen kann. OpenCOBOL finden Sie auf dieser Seite: http:// www.opencobol.org/. Imperative Programmiersprachen Imperative Sprachen waren die ersten Computersprachen, schon allein deshalb, weil die Maschinensprachen der Prozessoren meist imperative Sprachen sind. Man nutzt hin und wieder den Begriff prozedurale Sprachen, was aber nicht ganz richtig ist. Eine Prozedur ist ein Unterprogramm, das von einem Programm mehrfach genutzt werden kann. Prozedurale Sprachen stellen damit eigentlich eine Erweiterung der imperativen Sprachen dar. Es sind auch sequenzielle imperative Programme möglich, ohne jede Prozedur. Eine imperative Sprache beschreibt für den Computer, wie er zu einem bestimmten Ergebnis kommt. Das gilt nicht nur für Berechnungen, sondern für alles, was der Computer machen kann. Ist ein Bild darzustellen, so würde es im imperativen Programm beispielsweise heißen: »färbe den Punkt (105@220) in Rot«.

PL/1 steht für Programming Language One. Sie ist als imperative und prozedurale Sprache sowohl für die wissenschaftliche und geschäftliche als auch sogar für die Systemprogrammierung geeignet. Die Entwicklung von PL/1 fällt zusammen mit der Ankündigung des IBM-Systems 360 im Jahre 1964, das IBM als universellen Rechner für wissenschaftliche und geschäftliche Anwendungen verstand. Daher wollte man auch eine Sprache anbieten können, die die zahlreichen Geschäftsfelder befriedigend abdecken konnte. IBM ging davon aus, die Sprache Fortran so erweitern zu können, dass sie diesen Ansprüchen gerecht werden konnte. Das Komitee zur Bewertung dieses Vorhabens erkannte jedoch die Unmöglichkeit des Vorhabens und schlug eine völlige Neuentwicklung vor. Man nannte sie NPL für New Programming Language, was jedoch zu Namenskonflikten mit dem britischen National Physical Laboratory führte. Nach dem Zwischenschritt über MPPL kam man endlich auf PL/1. Bereits 1966 konnte man den ersten PL/1-Compiler ausliefern.

267

6.4

6

Von Lady Ada bis F#

Weil es im Grunde immer noch eine Großrechnersprache ist, findet man auch keine kostenlose PC-Version.

6.4.2

C

C gilt für viele noch immer als die Programmiersprache überhaupt, obwohl die Bedeutung, insbesondere wegen Java, zurückgegangen ist. Als man 1970 daran ging, in den Bell-Laboratories ein interaktives Betriebssystem, nämlich UNIX, zu entwickeln, das zahlreiche Nutzer gleichzeitig verwenden können, benötigte man eine systemunabhängige Programmiersprache, die aufgrund ihrer Hardwarenähe schnelle Programme möglich machte. C wurde zwischen 1971 und 1973 von Dennis Ritchie, einem Mitarbeiter der Bell Laboratories, erdacht und realisiert. Als Vorlage diente ihm die von Ken Thompson entwickelte Sprache B (was den Namen erklärt) von 1970, die wiederum von Martin Richards Sprache BCPL abstammt, die fünf Jahre zuvor entwickelt worden war. Den ersten C-Compiler schrieb Ritchie ebenfalls. Nach dem Abschluss der Entwicklungsarbeit an C wurde der UNIX-Kernel, der großteils in Assembler realisiert worden war, in C neugeschrieben. Es dauerte bis 1989, ehe man C standardisierte (ANSI C). Der Wildwuchs bis dahin brachte C trotz seiner weiten Verbreitung ziemlich in Verruf. C besitzt im Gegensatz zu ALGOL eine kurze, verdichtete Schreibweise. Es wird bis heute für hardwarenahe Programmierung genutzt, besitzt jedoch einige Schwächen, unter anderem fehlt eine Garbage Collection. Das bedeutet, dass der Programmierer nicht mehr benötigten Speicherplatz per Anweisung selbst freigeben muss. Eine Neubelebung erfuhr C 1979 durch die Weiterentwicklung zu C++, einer objektorientierten Variante der Sprache. Wieder kam die Entwicklung von AT&T, den Betreibern der Bell Labs, und der Entwickler hieß Bjarne Stroustrup. Das neue Konzept der objektorientierten Programmierung war damals allerdings schon fast 20 Jahre alt. Die erste Programmiersprache, die damit arbeitete, hieß Simula und wurde von Kristen Nygaard und Ole-Johan Dahl am Norsk Regnesentral (dem norwegischen Rechenzentrum) der Universität Oslo ab 1961 entwickelt. Um technische Simulationen im Bereich des Schiffsbaus besser programmieren zu können, hatten sie die Idee, ALGOL 60 zu erweitern, Daten und Code in sogenannten Objekten zu kapseln und diese entsprechend den realen Objekten miteinander in Beziehung zu setzen. Insbesondere sollte die Wiederverwendbarkeit von Code mit Hilfe eines Klassenkonzepts optimal realisiert werden – wobei die Klassen zur Verwendung beliebig verändert werden können.

268


Simula fand in der IT-Welt große Beachtung und wurde als Nischensprache genutzt.

6.4.3

Smalltalk

Diese Sprache entstand als dynamische, typfreie und objektorientierte Programmiersprache. Außerdem ist sie eine Interpreter-Sprache, weshalb man sich auch nicht mit der Definition der Sprache zufrieden gab. Smalltalk wurde gleichzeitig zu einem Entwicklungssystem ausgebaut, das selbst in Smalltalk geschrieben wurde. Weil es als Interpreter arbeitet, kann jeder aufgetretene Fehler nach dem Stoppen des Systems korrigiert werden, und es kann an der gleichen Stelle weiterinterpretiert werden. Theoretisch kann man sogar Änderungen, falls sie erforderlich werden, im Smalltalk-Code selbst vornehmen, während man im Debugger das Anwenderprogramm abarbeiten lässt. Das alles, ohne das eigene Programm neu starten zu müssen. Zur Entwicklung der Sprache kam es Anfang der 70er Jahre angeblich, weil man dem Entwicklungsteam (Adele Goldberg, Alan Kay, Dan Ingalls u.a.) im Xerox Forschungslabor freie Hand gelassen hatte. Es hatte sich an Simula orientiert und den ersten Smalltalk-Interpreter auch in Simula geschrieben. Nach mehreren Versionen wurde Smalltalk schließlich als Smalltalk 80 standardisiert. Smalltalk hat die Entwicklung zahlreicher moderner Programmiersprachen stark beeinflusst. Das fängt bei Visual Basic an, wo zwar nicht die OOP, aber die Ausrichtung auf einen grafisch orientierten GUI-Designer von Smalltalk übernommen wurde. Bjarne Stroustrup, der Smalltalk erlernt hatte, erweiterte C, mit dem er arbeiten musste, um OOP-Elemente und legte so den Grundstein zu C++. Java hat enorme Anleihen bei Smalltalk gemacht, und weitere Sprachen, wie Ruby, C#, Python oder Squeak, sind ohne Smalltalk undenkbar. Smalltalk kostete zu seiner Zeit viel zu viel Systemressourcen, um erfolgreich sein zu können. Den damals üblichen Rechnern fehlte nicht nur die Grafikfähigkeit, sondern auch Hauptspeicher und Rechenpower, um Smalltalk-Programme in erträglichem Tempo ausführen zu können. Heute ist das natürlich anders, und so kann man Smalltalk, sofern man sich mit so einer Uraltsprache abgeben möchte, in zahlreichen Dialekten aus dem Internet beziehen und nutzen. Einer der interessantesten Dialekte ist zweifellos Squeak. Praxis: Squeak Einige der ursprünglichen Smalltalk-Entwickler, wie Alan Kay und Dan Ingalls, entwickelten bei Apple Computer Smalltalk 80 zu dem System weiter, das man

269

6.4

6

Von Lady Ada bis F#

heute als Squeak kennt. Alan Key war besessen von der Idee, damit ein System zu schaffen, das selbst Vorschulkinder in die Lage versetzen sollte, funktionsfähige Programme zu schreiben. Dass er damit Erfolg hatte, zeigt die Aufnahme von Squeak in das OLPC-Projekt. Dabei geht es darum, Kindern in den Schwellenländern auch den Zugang zu modernen Computern zu ermöglichen. Deshalb nennt sich das Projekt auch »One Laptop per Child«. Als 100 $-Rechner-Projekt wurde es bereits erwähnt. Trotzdem ist Squeak eine vollwertige Smalltalk-Entwicklungsumgebung und geht sogar in manchen Dingen über die Möglichkeiten der üblichen Programmiersprachen hinaus (z. B. mit Morphing). Sie finden Squeak im Internet auf der Squeak-Homepage: http://www.squeak.org. Auf der DVD liegt es unter Software zum Buch\Kap06\Squeak. Eine weitere Squeak-Download-Seite findet man unter http://squeakde.cmsbox.ch/download, ein gutes, frei erhältliches Lehrbuch gibt es auf http:// www.squeakbyexample.org/. Beim Herunterladen darf man nicht vergessen, sich auch ein Imagefile mit downzuloaden. Es enthält das eigentliche System, das andere ist lediglich die SmalltalkMaschine. Zur Installation muss Smalltalk nur entpackt und in einem Verzeichnis auf der Platte abgelegt werden. Hat man nur die virtuelle Maschine nach dem Entpacken gestartet, fragt sie zuerst nach dem Imagefile. Die drei Dateien des Images entpackt man am besten mit in dem Verzeichnis mit der virtuellen Maschine. Jetzt startet das System ohne Probleme auf dem Image. Wenn Sie squeak.exe anklicken, öffnet sich ein Begrüßungsdialog (siehe Abbildung 6.12). Squeak ist sehr vielfältig und bietet von der einfachen textorientierten Programmierung bis zu 3D-Welten eigentlich alles, was die EDV zu bieten hat. Es versteht sich von selbst, dass man das nicht in wenigen Absätzen abhandeln kann. Wir wollen uns zunächst die ursprünglichen Smalltalk 80-Fähigkeiten ansehen, die prähistorischen Möglichkeiten sozusagen. Dafür öffnen Sie einen sogenannten Workspace: Tools 폷 Workspace. Bereits bei der ersten Smalltalk-Version gab es dieses Programmierfenster, genau in dieser Form. Das war 1970 und damals die einzige grafisch orientierte Entwicklungsumgebung der Welt.

270


Abbildung 6.12

Squeak-Dialog

Was kann Alan Kay anderes damit getan haben, als das obligatorische »Hello World«-Programm zu schreiben? Tippen wir also ein: Transcript show: ’Hallo für mehr Coding for Fun!’

Das wird nun nicht irgendwie übersetzt, sondern zunächst einmal mit der Maus markiert, so wie man das in einer Textverarbeitung macht. Man geht mit der rechten Maustaste ins Kontextmenü und wählt den Menüpunkt: Do it(d). Eine klare Anweisung. Aber nur leider passiert nichts. Warum? Die Anleitung lautet doch, in das sogenannte Transcript-Fenster einen Text auszugeben. Squeak würde das auch tun, nur das Transcript-Fenster ist gar nicht geöffnet. Also: Tools 폷 Transcript anklicken. Wenn wir nun die Anweisung interpretieren lassen, bekommen wir das gewünschte Ergebnis zu sehen. Ich hatte erzählt, dass Squeak viel mehr kann. Also bin ich Ihnen etwas schuldig, versuchen Sie das einmal: (StringMorph contents: 'More Fun, more Coding') openInHand

271

6.4

6

Von Lady Ada bis F#

Es genügt übrigens schon, den Cursor in der Codezeile stehen zu haben und Do it(d) aufzurufen (oder einfach (Strg) + (D) zu drücken). Nun haben Sie den Text am Cursor kleben und können ihn mit einem Klick überall ablegen, wo Sie wollen. Neben Do it(d) findet man auch Menüpunkte wie Print it, Inspect it oder Explore it im Kontextmenü. Um diese Funktionen auszuprobieren, genügt es, eine einfache Rechenaufgabe in den Workspace zu tippen und diese zu markieren, wie z. B.: 7 + 14

Das Ergebnis ist bekanntermaßen 21, doch liefert uns Do it(d) zunächst einmal gar nichts, nicht einmal im Transcript-Fenster. Ganz einfach, weil keine Ausgabenachricht vorliegt. Das kann man ändern mit Transcript show: 7 + 14

Print it liefert uns direkt hinter 7 + 14 die Lösung. Sie ist markiert, um sie gleich wieder löschen zu können. Bei Inspect it wird der Inspect-Browser geöffnet, und bei Explore it erhalten wir das Ergebnis in den verschiedenen Zahlensystemen angezeigt. Die zugrunde liegenden Überlegungen bei Smalltalk sind: »Alles sind Objekte.« und »Objekte erhalten Nachrichten.« 7 + 14 wird daher definiert als: Das Objekt 7 erhält die Nachricht + mit dem Parameter 14. Oder zu dem anderen Beispiel: Das Objekt Transcript erhält die Nachricht show für zeige an mit 7 + 14 als Anweisung, dessen Ergebnis anzuzeigen wäre. Das ist Objektorientierung in seiner reinsten Form. Selbst Java ist nicht in diesem Umfang OOP, wie es bei Smalltalk der Fall ist. Doch nun wollen wir uns aus den Gefilden von Smalltalk 80 in die Höhen von Squeak wagen. Dazu installieren wir ein sogenanntes Package mit dem Monticello Browser. Aufgerufen wird er über das Menü Tools 폷 Monticello Browser. Mit dem Button +Repository 폷 http machen wir ihm eine Quelle im Internet bekannt, von der er den Klatt-Sprachsynthesizer installieren kann. In das Textfeld fügen wir folgenden Text ein: MCHttpRepository location: 'http://www.squeaksource.com/Speech' user: '' password: ''

272


Mit der Accept-Schaltfläche wird der Dialog verlassen. Nun kann man die Zeile http://www.squeaksource.com/Speech im Browser anwählen und mit der OpenSchaltfläche öffnen. Es werden zwei Pakete angezeigt: 왘

왘

Speech mit den Dateien: 왘

Speech-dtl.10.mcz

왘

Speech-md.9.mcz

und SharedPool-Speech mit: 왘

SharedPool-Speech-dtl2.mcz

Sie wählen die Dateien nacheinander an und installieren sie mit Hilfe der Schaltfläche load. Ist die Sprachausgabe installiert, kann man bereits erste Experimente damit machen. Ausgeführt wird jedoch nicht mit Do it(d), sondern mit Print it. Speaker manWithHead say: 'Mehr Spass am Programmieren'

Den animierten Kopf wählen Sie über das Menü mit select an und klicken am sogenannten Halo auf das Löschen-Icon oben links. Es geht auch ohne animierten Kopf: Speaker woman say: 'Mehr Spass am Programmieren'

6.4.4

Pascal

Einer der ganz großen Informatikpioniere ist der Schweizer Informatikprofessor Niklaus Wirth. Er hat in seinem Leben ein ganzes Bündel an Programmiersprachen entwickelt. So war er bereits an der Entwicklung von ALGOL beteiligt. Die Art und Weise, wie man sich die Weiterentwicklung dieser Sprache vorstellte, gefiel ihm jedoch nicht, und er kehrte nach Zürich an die Eidgenössische Technische Hochschule zurück, wo er bis 1999 als Professor lehrte. Hier entwickelte er im Selbstauftrag von 1968 bis 1972 die Programmiersprache Pascal als Lernsprache, um den Studenten eine stilsichere und fundierte Programmierausbildung zu garantieren. In der Tat wurde Pascal auch vorrangig in der Ausbildung genutzt. Die Sprache zeichnet sich durch hohe Typenstrenge und klare Strukturierbarkeit aus. Pascal-Programme sind gut zu lesen und dadurch auch sicher im White-BoxTest3 nachzuvollziehen. Auch Pascal war Vorbild für einige Nachfolgesprachen. Am erfolgreichsten wurde TurboPascal von Borland. Es war lange Zeit der professionellere Gegner zu 3 Das ist eine Testart, bei der sich Tester den erstellten Code der Programmierer genau ansehen.

273

6.4

6

Von Lady Ada bis F#

Microsofts BASIC. Durch die immer anspruchsvolleren Windows-Versionen geriet es jedoch ins Hintertreffen. Eine Anpassung an die Objektorientierung machte aus Pascal die Sprache Delphi. Sie wurde allerdings genau wie die drei späten Sprachen von Niklaus Wirth, Modula (1973), Modula-2 (1977) und Oberon (1986), lange nicht so erfolgreich wie Pascal. Das lag auch daran, weil es zur Zeit der Heimcomputer kaum eine wirklich gute Alternative zu Pascal gab, später jedoch C und C++, die von UNIXMiddleware-Rechnern kamen und auf PCs immer weitere Verbreitung fanden. Auch heute findet man Pascal noch in der Lehre, wenn es darum geht, strukturierte prozedurale Programmierung zu erlernen. Auch Delphi wird noch zum Erlernen der OOP genutzt. Im technischen Einsatz findet man Pascal dort, wo es darum geht, kleine, solide Steuer- und Kontrollprogramme zu erstellen, die gute Wartungseigenschaften haben. Beispiele finden sich unter der Software für die Steuerung der Energieversorgung und in der Verkehrsleittechnik. Borland hat die Pflege von TurboPascal eingestellt, und so wurde es von dem Studenten Florian Paul Klämpfl nachprogrammiert, zunächst auf Basis eines 32-BitCompilers. Er nannte es FPK als Abkürzung seines Namens. Später wurde daraus FreePascal. Praxis Modesprachen wie Perl, Python oder Ruby haben Pascal mehr und mehr verdrängt. So wird dieser einst so vielgenutzten Sprache nichts anderes übrig bleiben, als zu einem Exoten zu werden. Deshalb möchte ich Pascal hier auch nicht weiter erläutern. Wie alle Sprachen, deren Urgroßmutter einmal ALGOL hieß, besitzt die Sprache eine recht leicht erlernbare Syntax, so dass es jedem ernsthaft Interessierten nicht schwerfallen sollte, sich mit den umfangreichen Dokumentationen im Internet schnell in diese Sprache einzuarbeiten. Ich möchte Ihnen jedoch erläutern, wie man einen freien Compiler auf einer virtuellen Betriebssystemumgebung einrichtet, um sich diese Sprache einmal in Funktion ansehen zu können. Dazu nutzen wir das erwähnte FreePascal. Die neueste Version dieses Entwicklerwerkzeugs findet man im Internet unter http://freepascal.org/. Die Windows-Version hat eine der üblichen Installationsroutinen, mit der man FreePascal später, falls erforderlich, wieder spurlos von der Festplatte tilgen kann. Zum Starten können Sie entweder das Icon auf dem Desktop nutzen, den Menüpunkt im Windows-Startmenü aufrufen oder die Datei fp.exe unter C:\Fpc\2.4.0\ bin\i386-win32\ anklicken.

274


Es öffnet sich ein Dialogfenster, das eine Text-und-Sonderzeichen-orientierte Oberfläche hat. Fenster werden mit ASCII-Sonderzeichen gerahmt. Von der Bedienung her ist es auch nicht anders als heute übliche Windows-Programme. Das archaische Aussehen kommt daher, weil FPC betriebssystemübergreifend verfügbar ist. Das Layout ist außerdem eine Art Referenz an die damalige TurboPascal-IDE – sie sah auch nicht viel anders aus. Der Standard, der das Aussehen prägt, nennt sich SAA (Systems Application Architecture) und wurde um 1988 von IBM eingeführt. Die Architektur bestand aus mehreren Komponenten, wobei CUA (Common User Access) die Gestaltung der Nutzeroberflächen beschrieb.

Abbildung 6.13

Pascal-IDE mit drei Quellcode-Dateien

275

6.4

6

Von Lady Ada bis F#

Doch zurück zu Pascal selbst. Im Gegensatz zu objektorientierten Programmen gab es unter Pascal noch die Unterscheidung zwischen Funktionen (function) und Prozeduren (procedure). Prozeduren sind ohne Rückgabewerk, während Funktionen Werte zurückliefern, wobei der Typ hinten in der Signatur4 steht und der Wert im Funktionskörper durch Zuweisung zum Funktionsnamen zurückgeht. Beispiele, die man sich unter Windows in jedem Fall anschauen sollte, sind Demo\graph\mandel.pp und Demo\win32\edit.pp. »Das Erlernen einer Computersprache ist wie das Erlernen der Muttersprache: Von der Sprachlosigkeit gelangt man mühsam zum Stammeln, kommt zum Stottern und über das Palavern schließlich zum Frotzeln.« – Anonymus

6.4.5

C++

Beim Thema C wurde C++ bereits erwähnt. AT&T, der Betreiber der Bell Labs, ließ die Sprache C von Bjarne Stroustrup für die OOP erweitern, so dass C++ entstand. C++ wurde 1999 genormt. Vom Typ her ist C++ eine sogenannte Multiparadigmen-Sprache, die folgende Programmiertechniken unterstützt: 왘

strukturierte Programmierung

왘

prozedurale Programmierung

왘

modulare Programmierung

왘


왘

generische Programmierung

C++ wird im Gegensatz zu Java oder den .NET-Sprachen bei der Entwicklung hochperformanter Software eingesetzt. Hier ist sie im Grunde auch nicht zu ersetzen. Da sich jedoch die IT-Technik ständig weiterentwickelt, besteht auch bei C++ ständig der Bedarf, verbessert zu werden. So erarbeitet das C++-Standardkomitee aktuell eine neue Version von C++ mit dem Namen C++10. Die 10 steht dabei für das erhoffte früheste Normierungsdatum. Allerdings wurde das Datum schon mehrmals verschoben. Ein wichtiges Ziel bei der Entwicklung des neuen Standards ist angeblich die Verbesserung der Erlernbarkeit. Die Sprache soll eindeutiger und damit leichter lesbar werden. 4 Signatur = Kopf einer Methode, Funktion oder Prozedur

276


Aktuelle C++-Compiler haben teilweise die kommenden Verbesserungen bereits integriert oder unterstützen sie, soweit es dem Compiler-Anbieter sinnvoll erscheint. Auch wenn die Norm bald veröffentlich wird, so wird es doch noch eine Weile dauern, bis die erhältlichen Compiler die meisten der neuen Funktionen unterstützen. Informationen zur neuen C++-Version finden Sie auf der Seite http:// www2.research.att.com/~bs/C++0xFAQ.html. Praxis Wer C++ erlernen möchte oder mit geringen Kosten Programme für den nichtkommerziellen und privaten Bereich programmieren will, sieht sich am besten die Entwicklerwerkzeuge der Express-Linie von Microsoft einmal an. Darunter findet man auch ein Visual Studio Express C++. Es handelt sich dabei um etwas eingeschränkte Versionen aus der Visual-Studio-Reihe, die kostenlos aus dem Internet bezogen werden können. Die Version der Sprache entspricht der aktuellen MS C++-Version. Als Entwicklungswerkzeug dient der neu überarbeitete Code-Editor auf Basis der Windows Presentation Foundation (WPF). Natürlich fußt die gesamte Entwicklungsumgebung auf dem bekannten und unter Entwicklern gefragten .NET-Framework 4.0 Aber man findet dort nicht nur die zur Softwareentwicklung nötigen Werkzeuge, sondern auch Ideen für Eigenentwicklungen und reichlich Unterstützung in Form von Dokumentationen und einer regen Community. Das Ganze nennt sich coding4fun, wie sonst ... Die entsprechende Homepage ist http://www.microsoft.com/germany/msdn/coding4fun/developer_tools.mspx. Der Download ist von folgender Seite möglich: http://www.microsoft.com/germany/express/download/ default.aspx. Da C++ keine Sprache ist, die man mal eben so ausprobiert, kann man diese von Microsoft angebotene Möglichkeit nur empfehlen. Besonders interessant ist sie natürlich für Studenten und junge Lernende, die sich ohnehin in diese Sprache einarbeiten müssen. Aber natürlich steht es auch jedem hobbymäßig Interessierten frei, sich einmal auf der Coding4Fun-Homepage umzusehen. Wer sich – aus welchen Gründen auch immer – davor scheut, eine MicrosoftSprache zu nutzen, findet im Netz zu C++ auch andere Werkzeuge, die der echten Open-Source- oder Freeware-Lizenz unterstellt sind. Eine recht brauchbare freie Entwicklungsumgebung für C++ liegt unter http://www.codeblocks.org/.

277

6.4

6

Von Lady Ada bis F#

6.4.6

Prolog

Nachdem die meisten Programmiersprachen, die in den 60er und 70er Jahren entstanden, lediglich Abwandlungen und Verbesserungen der Sprache ALGOL darstellten, kam mit Prolog eine ganz neue Sprache, die 1972 am Institut National de Statistique et d'Économie Appliquée von Alain und Philippe Roussel Colmerauer entwickelt wurde. Der Name Prolog ist eine Abkürzung von Programmation en Logique, was übersetzt »Programmieren mit Logik« bedeutet. Die Idee dahinter ist, eine Sprache zu schaffen, die auf der Prädikatenlogik erster Ordnung beruht, die also bedingt Schlüsse ziehen kann, wenn ihr entsprechende Aussagen zur Verfügung stehen. Man kann sich das etwa so vorstellen wie bei den folgenden Sätzen: »Fräulein Meier besitzt einen Hund.« »Jeder, der einen Hund besitzt, geht irgendwann mit diesem Hund spazieren.« Jeder Mensch ist nun in der Lage, den Schluss zu ziehen: »Fräulein Meier geht irgendwann mit ihrem Hund spazieren.« Auch der Computer kann das, wenn man Aussagen und Fragen entsprechend formuliert. Genau das haben die zwei Entwickler mit Prolog möglich gemacht. Deklarative Programmiersprachen In deklarativen Sprachen beschreibt man nicht mehr den Lösungsweg, sondern nur das Ergebnis. Der Compiler wandelt das Programm so um, dass es ausgeführt werden kann. Wenn wir den Rechner ein Bild zeichnen lassen, beschreiben wir nun also nicht mehr, wie er die einzelnen Pixel färben soll, sondern wir beschreiben, wie die Pixel des Bildes aussehen sollen. Umgangssprachlich etwa: »Bildpunkt (105@220) besitzt den Farbton Rot«. Dieses Bilderbeispiel (siehe Kasten »Imperative Programmiersprache« in Abschnitt 6.4.1, »COBOL und PL/1«) zeigt sehr schön, dass der Unterschied zwischen den Paradigmen gar nicht so gravierend ist. Andere Programmaufgaben führen natürlich zu Programmen, die wesentlich größere Unterschiede zwischen den Paradigmen zeigen.

Ein Onlinebuch zum Erlernen von Prolog (in Englisch) finden Sie unter http:// www.learnprolognow.org/.

6.4.7

Ada

In den 70er Jahren stellte man im Pentagon bei einer Untersuchung fest, dass man fast 500 verschiedene Programmiersprachen aktiv nutzte und die Kosten für die Aus- und Weiterbildung der Mitarbeiter in diesen Sprachen enorm waren.

278


Außerdem bestand die Gefahr, dass man auf absehbare Zeit für die eine oder andere Sprache keine Fachleute, aber auch keine Hard- und Software mehr finden würde. Also machte man eine Ausschreibung, um eine Sprache zu finden, die den größten Teil der verwendeten Sprachen ersetzen konnte. Keine der existierenden Sprachen war dafür geeignet, so entschloss man sich, eine neue Sprache entwickeln zu lassen. Mit Hilfe einer Ausschreibung fand man vier Kandidaten, die mit Red, Green, Blue und Yellow gekennzeichnet wurden, weil der Firmenname aus Übervorteilungsgründen geheim bleiben musste. Im Mai 1979 fiel die Entscheidung zu Gunsten von Green von der französischen Honeywell-Bull mit dem Entwickler Jean Ichbiah. Weil die Sprachbeschreibung am 10. Dezember 1980 genehmigt worden war, dem Geburtstag der ersten Programmiererin Lady Ada Lovelace, erhielt die Sprache den Namen Ada. Die Standardbezeichnung vom Pentagon ist übrigens MILSTD 1815, weil Ada im Jahr 1815 geboren wurde. Als eines der Vorbilder für die Sprache hat Pascal gedient. Das wichtigste Argument für Ada ist jedoch immer noch die unbedingte Validierung der Ada-Compiler. Das geschieht mit Hilfe der Ada Conformity Assessment Test Suite (ACATS), einer Programmsammlung, die von den Compilern problemlos abgearbeitet werden muss. Nur Compiler, die der Norm entsprechend fehlerfrei arbeiten, dürfen sich überhaupt Ada-Compiler nennen. Aber auch solche Bestimmungen können nicht alle Probleme verhindern, die in Verbindung mit Software auftreten. So geht der bisher teuerste Softwarefehler aller Zeit auf ein Ada-Programm zurück. Was natürlich auch daran liegt, dass Ada im Hochsicherheits-, im militärischen und im Luftfahrtbereich eingesetzt wird. Das Softwareproblem trat beim Erstflug (V88) der europäischen Ariane 5-Rakete am 4. Juni 1996 um 9 Uhr 35 Ortszeit auf Korou auf. Eine Variable bh (was für bias horizontal steht, also den horizontalen Wert für die Ausrichtung) bekam einen Überlauf. Das bedeutet bei Programmiersprachen im Allgemeinen, dass der Wert der Variablen über den maximalen Wert des Typs läuft. Meist wird dadurch aus einer sehr großen eine sehr kleine Zahl. In Ada werden allgemein Techniken benutzt, die solche Überläufe verhindern. Im Fall dieser Variablen hatte man darauf verzichtet, weil die Rechnerauslastung einen bestimmten Grad nicht überschreiten durfte und deshalb notwendige Rechenarbeit unterlassen wurde. Zudem war die Software Bestandteil des Vorgängers der Ariane 4 und wurde – aus Zeitgründen wenig getestet – einfach übernommen.

279

6.4

6

Von Lady Ada bis F#

Die Trägerrakete mitsamt ihren vier Satelliten ging verloren, und der Schaden betrug 290 Millionen Euro, was damals fast 2 Milliarden Franc entsprach. Das hatte dem Ansehen Adas einen schweren Schlag versetzt, obwohl die Sprache im Grunde nicht für den Fehler verantwortlich gemacht werden kann. Trotzdem verlor Ada seit ihrer Entwicklung ständig an Bedeutung, insbesondere, weil sie nicht oft gelehrt wird und Modesprachen wie C++ oder Java immer wieder bevorzugt wurden. Praxis Ada-Compiler waren früher nicht gerade billig. Weil sie validiert werden müssen, kostet ihre Entwicklung viel Zeit und damit auch viel Geld. Aus diesem Grund hat die amerikanische Luftwaffe einen Ada-Compiler entwickelt, den sie kostenlos abgibt. Er wurde unter die GNU-Lizenz gestellt. Man findet ihn im Internet unter http://www.gnu.org/software/gnat/. Deutsche Ada-User findet man unter http://www.ada-deutschland.de/aktuelles/index.html.

6.4.8

Python

Sprachen wurden schon oft für ein bestimmtes Betriebssystem entwickelt. So auch Python, das 1992 von Guido van Rossum für Tanenbaums verteiltes Microkernel-Betriebssystem Amoeba am Centrum Wiskunde & Informatica in Amsterdam entwickelt wurde. Amoeba geriet in Vergessenheit, während sich Python etablieren konnte. Die Programmiersprache wird oft als Skriptsprache eingesetzt und unterstützt drei Vorgehensweisen: 왘

funktionale Programmierung

왘


왘

aspektorientierte Programmierung

Es wird stets ein Zwischencode erzeugt, der von einer Art Python-Interpreter ausgeführt wird. In Python wird die Struktur nicht durch Klammerung festgeschrieben, sondern durch Einrücken der Zeilen. Das Verfahren macht Programme zwar übersichtlich, aber Einrückungen können durch Leerzeichen oder Tabs erzeugt werden, und dies kann in Python zu Schwierigkeiten bei der Interpretation führen. Die offizielle Webseite findet man unter http://www.python.org/, ein deutsches Handbuch gibt es unter http://tutorial.pocoo.org/.

280


6.4.9

BASIC/VB

BASIC ist wie C ein Programmiersprachen-Fossil, das es durch zahlreiche »Frischzellkuren« geschafft hat, stets aktuell zu bleiben. Der Name BASIC ist trotz seiner Länge eine Abkürzung, und zwar für Beginner’s All-purpose Symbolic Instruction Code, was übersetzt in etwa »symbolische Allzweck-Programmiersprache für Anfänger« bedeutet. BASIC, das stets großgeschrieben wird, wurde 1964 von John George Kemeny und Thomas Eugene Kurtz am Dartmouth College entwickelt. Wie der Name schon sagt, war es eine einfache Programmiersprache mit geringem Befehlsumfang, aber Befehlen, die der englischen Sprache entnommen und damit einfach zu erlernen waren. BASIC wurde für fast alle Rechner angeboten. Die ersten IBM-PCs hatten es sogar im ROM integriert, so dass es sofort nach dem Einschalten verfügbar war. Auch zahlreiche Heimcomputer waren mit einem ROM-BASIC ausgestattet. Der C64 besaß ebenfalls einen 9 KB großen BASIC-Interpreter in seinem 20 KB ROM. Der große Vorteil dieser BASIC-Interpreter war natürlich, dass es keinen Kompiliervorgang gab. Dafür war das BASIC aber entsprechend langsam. Den größten Erfolg hatte BASIC in der von Microsoft ab 1991 angebotenen Visual-Basic-Version. Man hatte den QuickBASIC-Compiler, den man schon seit 1985 auslieferte, mit einer grafischen Entwickleroberfläche für Fenstersysteme ausgestattet. Es gab sowohl eine Version für DOS und die damals üblichen Blockgrafik-Fenster als auch eine für MS Windows. Die enge Verknüpfung zwischen diesem sogenannten grafischen GUI-Editor und dem Compiler erwies sich als Geniestreich. VB, wie es kurz genannt wurde, verkaufte sich von Anfang an überdurchschnittlich gut. Aufgrund der Möglichkeit, grafische Oberflächen mit dem GUI-Editor durch einfaches Positionieren der Bestandteile zusammenzustellen, eignet sich VB auch sehr gut für das sogenannte Rapid Application Development (RAD)5. VB wurde, wie erwähnt, ständig weiterentwickelt und bietet natürlich längst OOP. Mit der Entwicklung des .NET-Frameworks wurde natürlich auch VB überarbeitet und mit aufgenommen. Es nannte sich ab 2002 Visual Basic .NET, was sich allerdings 2005 wieder änderte. Jetzt heißt es wieder Visual Basic mit der aktuellen Versionsnummer, z. B. Visual Basic 10. Durch die Aufnahme ins .NET-Framework ergaben sich zahlreiche Änderungen, die VB zu einer modernen Sprache machten, etwa gleichwertig mit C#. Leider 5 Rapid Application Development = schnelle Softwareentwicklung

281

6.4

6

Von Lady Ada bis F#

mussten aus Kompatibilitätsgründen mit den alten BASIC-Versionen einige Dinge drin bleiben, die sich nicht besonders schön machen. VB ist eine sehr gut dokumentierte Sprache. Insbesondere die Dokumentation des .NET und das sogenannte MSDN Library lassen keine Fragen offen. Praxis BASIC als Sprache ist in ihrer modernen Form mit Microsoft verwurzelt wie Java mit Sun. Bill Gates hat BASIC zwar eigentlich nicht erfunden, aber Microsoft hat mit seinen BASIC-Entwicklungswerkzeugen den Markt so stark dominiert, dass man Microsoft und BASIC in einem Atemzug nennt. Die modernen MS-BASICVersionen haben freilich mit dem ersten BASIC nichts mehr gemein. Sie sind nicht einmal unbedingt so sehr mit Visual Basic verwandt, wie man es vielleicht glauben mag. Visual Basic 2010 unter dem .NET-Framework ist eine moderne Sprache geworden, die Objektorientierung und andere Paradigmen nicht nur ansatzweise zur Verfügung stellt.

Abbildung 6.14

282

Lernprogramm unter VB


Auch bezüglich dieser Sprache stellt die Homepage des coding4fun-Projekts eine ideale Anlaufstelle dar. Die Entwicklerwerkzeuge findet man, wie bereits erwähnt, unter http://www. microsoft.com/germany/msdn/coding4fun/developer_tools.mspx. Der Download von VB ist von folgender Seite möglich: http://www.microsoft.com/germany/ express/download/default.aspx Nach der Installation und dem Start des Programms kann man sich mit Hilfe von Lernprogrammen per Learning by Doing in die Sprache einarbeiten (siehe Abbildung 6.14).

6.4.10 Ruby Ruby ist eine der modernsten heute aktiv genutzten Programmiersprachen. Sie entstand 1993, nachdem der japanische Student Yukihiro Matsumoto, unzufrieden mit den verwendeten Skriptsprachen, auf die Idee kam, eine eigene Sprache zu kreieren. Im Dezember 1995 gab er die erste Version einer neuen Sprache frei. Sie wurde in Japan ähnlich erfolgreich wie Perl und Python anderswo. Weil die meisten Dokumentationen jedoch in Japanisch und nicht in Englisch vorlagen, tat sich die Sprache erst einmal schwer. Etwa ab der Jahrtausendwende wurde mehr dafür getan, und die Sprache fand auch in anderen Ländern ihre Liebhaber.

6.4.11 Java Die uneingeschränkte »Königin« der modernen Programmiersprachen ist Java – natürlich nicht ohne Kritiker und Neider. Zugegebenermaßen ist Java wirklich nicht mehr als ein neuer objektorientierter C-Dialekt. Ein paar Unterschiede gibt es natürlich, aber damit kann man den ungewöhnlichen Erfolg dieser Sprache kaum erklären. 1995, als Java veröffentlicht wurde, kamen schon eine ganze Menge glücklicher Umstände zusammen. Um es genau zu sagen: Es war am 23. Mai 1995 in den »San Jose Mercury News«. Man benötigte unbedingt eine Sprache fürs Internet, das WWW begann sich rasant auszubreiten, und – was fast noch wichtiger war – Java war kostenlos. Ganz am Anfang, 1991, standen der Name Oak – nach der Eiche vor Goslings Fenster, der jedoch aus Urheberrechtsgründen wieder fallen gelassen wurde – und die Entwickler James Gosling, Patrick Naughton, Mike Sheridan und Bill Joy bei Sun Microsystems. Von der ersten Version, Java 1.0, bis zur aktuellen Version Java 7 hat Java eine ganze Menge Weiterentwicklungen erfahren. Nach und nach wurde die Sprache 283

6.4

6

Von Lady Ada bis F#

zu einer der am häufigsten verwendeten Programmierwerkzeuge überhaupt. Vom programmierbaren Handy bis zur Anwendung einer Großbank kann man alles mit Java programmieren. Wer bereits C-Programme geschrieben hat, dem fällt der Umstieg auf Java nicht schwer – auch einer jener Punkte, die den Erfolg von Java ausmachten. C war in den 90ern die meistgenutzte Programmiersprache. Auch für Anfänger hatte Java keine unüberwindlichen Hürden. Die OOP war in Java so implementiert, dass man sie leicht erlernen konnte. Kern der Java-Programmierung ist die Klasse, die ausführbaren Methoden stellen die funktionalen Bestandteile der Sprache dar. Eine Klasse wird einfach geschrieben wie Prozeduren in den alten Sprachen. Dadurch wird das Programm zur Klasse. Der Name der Hauptklasse muss mit dem Dateinamen übereinstimmen. public Class VielSpaß { }

Aus der Klasse kann ein konkretes Objekt gemacht werden, indem man sie mit new instanziiert. Im Code der Klasse gelingt das mit Hilfe der main-Methode, die beim Programmstart vom Betriebssystem aufgerufen wird. public class VielSpaß { /** * @param args */ public static void main(String[] args) { VielSpaß spass = new VielSpaß(); spass.print(); } }

Durch VielSpaß spass = new VielSpaß(); erhält man das Objekt spass. Es enthält die Methoden der Klasse und kann diese per Nachrichten-Aufruf nutzen: spass.print();

284


Natürlich muss eine solche Methode in der Klasse auch definiert sein, so dass das fertige Java-Programm folgendermaßen aussieht: import javax.swing.JOptionPane; public class VielSpaß { /** * @param args */ public static void main(String[] args) { VielSpaß spass = new VielSpaß(); spass.print(); } private void print() { JOptionPane.showMessageDialog(null, "Noch mehr Spaß mit Java und Co.", "Wichtige Meldung", JOptionPane.OK_CANCEL_OPTION); } }

Speziell zu Java gibt es so viele Dokumentationen und Handbücher im Internet wie zu keiner anderen Sprache vorher. Deshalb wird auch hier kein noch so knapper Kurzlehrgang in Java folgen. Wer möchte, kann sich Eclipse installieren, die meistgenutzte Entwicklungsumgebung für Java. Mit der Onlineliteratur kann man sich Java in wenigen Tagen und Wochen selbst beibringen. Das kurze Beispielprogramm finden Sie natürlich auf der DVD unter Software zum Buch\Kap06\Java. Die Datei VielSpaß.jar ist eine lauffähige Java-Datei, die mit der Java Virtual Machine gestartet werden kann. Wir kennen das ja schon: java -jar VielSpaß.jar

Zusätzlich ist das Eclipse-Projekt im VielSpass-Verzeichnis auf der DVD abgelegt. Es ist wirklich nur ein winziges Beispiel, das einen Dialog mit einer kurzen Meldung öffnet. Ich kann mir vorstellen, dass etliche meiner Leser an diesen ganzen Java-Beispielen, die auf der DVD liegen, etwas ganz gewaltig stört: Man benötigt immer eine virtuelle Maschine, um sie starten zu können. Java muss also instal-

285

6.4

6

Von Lady Ada bis F#

liert sein. Ich darf Ihnen verraten, dass sich auch etliche Softwareentwickler daran stören. Darum haben sich auch einige von ihnen aufgemacht, diesen Sachverhalt zu ändern, zumindest, soweit es Windows angeht. Es gibt ein Tool, das sich JSmooth nennt und das Java-Klassen so in einer exeDatei verstaut, dass sie auch wie eine solche abläuft. Man spricht davon, Klassen zu wrappen. Das Programm finden Sie im Internet unter http://jsmooth.sourceforge.net/download.php. Es liegt ebenfalls auf der DVD im Java-Verzeichnis. Damit wollen wir nun aus der VielSpass.jar eine VielSpass.exe machen. Dazu benötigen wir eine Jar-Datei, die den sogenannten Java-Bytecode enthält. Es ist eine einfache Zip-Datei, die nur eine andere Endung hat. Wenn man sie umtauft, kann man sich ihren Inhalt mit einem Zipper ansehen. Es gibt darin zwei Verzeichnisse: Meta-inf und ctrl. ctrl enthält die lauffähigen Klassen. Mit diesem Wissen ausgestattet, starten wir das installierte JSmoothProgramm. In der linken Spalte sehen Sie die Funktionen, mit denen die Umwandlung gelingt. Mit Skeleton fangen wir. In diesem Dialog brauchen wir nur in der ComboBox Windowed Wrapper auszuwählen, also den Bau einer Windows-exe festzulegen. Unter Executable müssen wir ganz oben den Namen für die exeDatei eingeben, also »VielSpass.exe«, darunter können wir ein Icon festlegen, das für die exe-Datei stehen soll. Wenn man keine entsprechende Sammlung hat, kann es sich lohnen, das C:\Windows-Verzeichnis nach *.ico-Dateien zu durchsuchen. Im Feld Current Directory kann man das Temp-Verzeichnis auswählen. Unter Application muss man die Main-Klasse angeben, was in diesem Fall »ctrl.VielSpass« ist. Außerdem sollte man das Jar einbetten lassen, da man es sonst immer der exe-Datei mitgeben muss. Dazu aktiviert man Use an embedded jar und trägt »VielSpaß.jar« in das entsprechende Feld ein (siehe Abbildung 6.15). Nun geht es bereits ans Kompilieren. Das gelingt entweder über das Icon mit dem Rad aus der Icon-Leiste oder über den Menüpunkt Project 폷 Compile... Der Wrapper meldet den Erfolg oder den Misserfolg. Die erzeugte Datei findet man schließlich im Verzeichnis. Sie kann nun wie eine exe-Datei auf jedem Rechner genutzt werden, die Java VM muss allerdings installiert sein. »Java ist, wie der Name erkennen lässt, eine Programmiersprache, die von zwei großen Kaffeeproduzenten gesponsert wurde.« – Anonymus

286

Noch mehr Spaß: Ein Blick in Microsofts Forschungsabteilung

Abbildung 6.15

JavaJar in JSmooth angeben

6.5

Noch mehr Spaß: Ein Blick in Microsofts Forschungsabteilung

6.5.1

F#

Seit C 1971 von Dennis Ritchie aus der Programmiersprache B von Ken Thomson entwickelt wurde, gab es immer wieder Programmiersprachen, die mit einem Buchstaben als Namen ausgekommen sind. Eine der neueren nennt sich nun F# und wird oft mit dem Synonym einer eierlegenden Wollmilchsau betitelt. In der Tat zeigte sich bei Java, das sich innerhalb kurzer Zeit zur meistgenutzten Sprache hochkämpfte, dass eine Sprache, die zu sehr auf ein Paradigma zugeschnitten ist (bei Java ist es die Objektorientierung), die kreative Programmentwicklung teilweise behindert. Wie das F schon andeutet, ist F# vor allem erst einmal eine funktionale Programmiersprache. Darüber hinaus kann man damit auch imperativ oder objektorientiert programmieren. Entwickelt wurde F# von 2003 an bei Microsoft Research, der Forschungsabteilung des Softwaregiganten (http://research.microsoft.com/en-us/default.aspx). Nun, wo F# die Marktreife erreicht hat, wird es als Teil von Visual Studio 2010 mit ausgeliefert.

287

6.5

6

Von Lady Ada bis F#

6.5.2

Microsoft Research (MSR)

Microsoft Research ist der Name der Forschungsabteilung von Microsoft. Sie wurde im Jahr 1991 gegründet, um Forschungen im Bereich der Programmiersprachen und Betriebssysteme weltweit koordiniert und mit Unterstützung der besten Forscher durchzuführen. Aufgrund der finanziellen Unterstützung vom Mutterkonzern gehört Microsoft Research zu den größten Forschungseinrichtungen der Welt. Viele Informatikgrößen sind bei Microsoft Research angestellt oder arbeiten dort befristet. Wenn man Microsoft und seine Möglichkeiten real beurteilen will, ist es kein Fehler, sich einmal die Webseite dieser Forschungsgesellschaft anzusehen: http:// research.microsoft.com/en-us/. Es gibt dort immer etwas Neues zu entdecken. Ob es nun das WWT (WorldWide Telescope) ist – ein virtuelles Fernrohr (http://www.worldwidetelescope.org/webclient/), mit dem man das Weltall erforschen kann, ohne einen Fuß vor die Tür zu setzen –, ein neues Betriebssystem oder aber vielleicht eine ganz neue Programmiersprache. »Java is the most distressing thing to hit computing since MS-DOS.« – »Java ist das Bedauerlichste, was die Computertechnik seit MS-DOS erlebt hat.« – Alan Kay

6.6

Lesen Sie weiter


Beschreibung

http://www.elektronik-kompendium.de/ sites/dig/1109101.htm

Umrechnung von Zahlensystemen

http://www.wolframscience.com/prizes/ tm23/images/Turing.pdf

Turings Originalartikel zur Turingmaschine

http://heikomentzel.de/turing/

Turingmaschine von Heiko Mentzel

http://ironphoenix.org/tril/tm/

sehenswerte Internet-Turingmaschine, die die großen Biber errechnen kann

http://web.bvu.edu/faculty/schweller/ Turing/Turing.html

Turingmaschine, die einen Java-Preis gewonnen hat

http://ais.informatik.uni-freiburg.de/ turing-applet/

Turingmaschine der Uni Freiburg

288

Lesen Sie weiter

URL

Beschreibung

http://de.wikipedia.org/wiki/Ameise_%28 Turingmaschine%29

Ameisen in der Turingmaschine

http://noebis.pi-noe.ac.at/javanuss/ node164.html

Turmiten als spezielle Ameisen

http://noebis.pi-noe.ac.at/javanuss/ node163.html

noch einmal Ameisen

http://www.ureda.de/php/spider/ anzeige.php3?id=277

Artikel zum Turingtest

http://www.heise.de/newsticker/meldung/ 97991

die einfachste universelle Turingmaschine

http://www.wolframscience.com/prizes/ tm23/background.html

Wolframs Seite, mit Hinweisen zu Turingtests

http://www.schoene-aktien.de/ibm1_alte_ aktien.html

IBM-Geschichte

http://www.linux-fuer-alle.de/doc_ show.php?docid=29&catid=8

der Linux-vi

http://wiki.ubuntuusers.de/Vim

vi-Bedienung für Ubuntu

http://www.emsps.com/oldtools/msbasv.htm Geschichte der BASIC-Versionen http://www.xs4all.nl/~jmvdveer/algol.html

ALGOL 68-Interpreter

http://www.netcobol.com/

NetCobol-Seite

http://home.roadrunner.com/~pflass/PLI/

PL/1-Seite

http://www.python.org/

Python-Homepage

http://www.python.de/

deutsche Python-Seite

http://www.perl.com/

Perl-Homepage

http://www.ruby-lang.org/de/

Ruby-Homepage

http://www.pharo-project.org/home

Pharo(Smalltalk)-Homepage

http://pharobyexample.org/

ausgezeichnetes Smalltalk-Lehrbuch

http://www.lisarein.com/alankay/tour.html

Alan Kay und die Geschichte des Computers

http://www.od.shuttle.de/evb-1/ squeakdoc/

Squeak-Onlinebuch

http://www.java.com/de/download/ manual.jsp

Java-Download-Seite

http://research.microsoft.com/en-us/

Microsoft-Forschungsinstitut

http://research.microsoft.com/en-us/um/ cambridge/projects/fsharp/

F#-Homepage

289

6.6

6

Von Lady Ada bis F#

Literatur zum Kapitel Bongers, Frank: XHTML, HTML und CSS – Handbuch und Referenz. Mit CD. Galileo Press 2007. Wortmann, Till: Die Computer-Fibel. Galileo Press 2004. Friedman, Vitaly: Praxisbuch Web 2.0. Galileo Press 2007. Kretschmar, Stephanie: Alan Turing. Sein Leben und sein Werk (broschiert). GRIN Verlag. 2007 Shieber, Stuart M.: The Turing Test: Verbal Behavior as the Hallmark of Intelligence. Engl. B&T Verlag. 2004 Ebbinghaus, Heinz-Dieter: Turingmaschinen und berechenbare Funktionen 1. Springer Verlag. 1970

290

Software –»Weichware« – ist der eigentliche Konjunkturmotor des Computerzeitalters. Nicht Thomas J. Watson von IBM, sondern Bill Gates von Microsoft war lange Zeit der reichste Mann der Welt. Software ist der Treibstoff, das Öl des Computerzeitalters. Insbesondere die Anwendungssoftware hat den größten betriebswirtschaftlichen Effekt, sie wurde praktisch zum Synonym für Rationalisierung.

7

Softwaregeschichte(n)

1969

1976

1984

1987

2001

Software AG SAP Star Office Power Point/MS Office Eclipse

7.1

Vom technischen Wunder zur Büromaschine

Mit dem Computer wurde auch die Software erfunden. Sie ist etwas Besonderes, was es zuvor in der Natur so nicht gegeben hat, und dennoch etwas Altbekanntes. Philosophisch betrachtet ist sie das menschliche Produkt, das die meiste Ähnlichkeit mit unserem subjektiven Selbst besitzt. Oder anders ausgedrückt: Es scheint, als sei unser Ich so etwas wie Software, das auf dem »Computer« Gehirn ausgeführt wird. Sinngemäß müssten wir den Begriff Software vielleicht mit Steueranweisungen übersetzen, wortwörtlich bedeutet es natürlich «Weichware«.

291

7


Der Begriff Software wurde erstmals 1958 von dem amerikanischen Statistiker John Wilder Tukey in einer Veröffentlichung im American Mathematical Monthly genannt. Paul Niquette datiert die Entstehung des Begriffs dagegen auf das Jahr 1953. Steueranweisungen für Maschinen gab es bereits lange vorher in den verschiedensten Formen. Selbst Lochkarten wurden bereits bei mechanischen Webstühlen oder den Pianolas für die Steuerung verwendet. Steueranweisungen sind auch nichts anderes als Daten oder genauer gesagt Informationen, daher ließen sie sich genau wie die Nutzdaten im Speicher des Computers ablegen und sogar bearbeiten. Diese Idee von Neumanns machte erst aus den Steueranweisungen das, was wir heute unter Software verstehen, und aus dem Rechner mit fest vorgegebenen Steueranweisungen einen Computer nach der Von-Neumann-Architektur. Die ersten mechanischen Rechner, wie die Maschine von Antikythera oder der Leibniz-Rechner, benötigten kein Programm, weil die Steuerung der mechanischen Abläufe im Aufbau der Maschine integriert war. Eine sogenannte Universalmaschine wie der Computer ist dagegen ohne Software nutzlos. Da er jeden Zustand annehmen kann, benötigt er für einen bestimmten zu erreichenden Zustand Anweisungen, um genau in diesen Zustand versetzt zu werden. Diese Zusammenhänge zeigt bereits die Turingmaschine in aller Deutlichkeit. Nach dem Zweiten Weltkrieg stieg mit der wachsenden Zahl verfügbarer Rechner auch der Bedarf an Software. Diese wurde zunächst von den Forschern, die die Rechner für ihre Arbeit nutzten, selbst erstellt. Mathematiker oder Physiker wurden hinzugezogen, und schließlich entstand der Beruf des Programmierers und der des Informatikers. Die Computerhersteller lieferten zunächst keinerlei Software zu ihren Geräten. Erst als Betriebssysteme erforderlich wurden und auch noch ganz speziell für jeden Rechnertyp, sahen sie sich gezwungen, diese Software mitzuliefern und daher auch erstellen zu lassen. Anfangs waren die Systeme so speziell, dass die Betriebssoftware gar nicht außer Haus programmiert werden konnte. Mit den ersten in Serie gebauten Maschinen wurde das anders. Erstmals wurden Auftragsarbeiten an die neu entstehenden Softwarehäuser vergeben, um die Rechner samt Software immer termingerecht ausliefern zu können. Microsoft war z. B. eine dieser neuen Firmen. Schon früh hatten sich Gruppen von Software herausgebildet. Da gibt es zunächst einmal die Software, die für den Betrieb des Computers erforderlich ist: Betriebssysteme, Treiber und Emulatoren. Wichtig ist zudem die Software zur Software-

292


entwicklung, die zunächst aus Assemblern, Compilern und Linkern bestand. Sie entwickelte sich stetig weiter bis zu modernen Entwicklungsumgebungen wie IDEs, Repositorys, Profiler und Debugger. Schließlich gibt es noch das unübersehbare Feld der Anwendungssoftware – von der einfachen Textverarbeitung über Tabellenkalkulation, Datenbanken, schließlich Synthesizer-Software und CAD-Systemen bis zu Animationsprogrammen für 3D-Filmszenen. Eine andere Gruppe, die von Anfang an dabei war, bilden die Spiele. Nüchterne Programme zu programmieren ist eine trockene Tätigkeit. Mit dem Computer als Universal-Datenverarbeitungsmachine kann man aber auch spielen. Anfangs, als die Prozessorzeit an den Großrechnern noch abgerechnet werden musste, war es schwierig, Spiele zu entwickeln oder gar am Rechner zu spielen. Es gab noch keinen Markt für Computerspiele und daher auch keine Möglichkeit, die CPU abzurechnen. Mit den Mini- und Microrechnern änderte sich das sehr schnell, und heute zählen die Computerspiele zum umsatzstärksten Segment der Rechnersoftware. Inzwischen gibt es für alles, was man nur irgendwie mit dem Computer bearbeiten kann, auch Software. »Schreibmaschinen dienen zum Schreiben, Rechenmaschinen dienen zum Rechnen. Wozu braucht man nun eigentlich Computer?« – Anonymus

7.1.1

Software, die Nutzen bringt

Während die allererste Software als Individuallösung auf den großen Rechnern im Batchbetrieb ausgeführt wurde, kam mit der interaktiven Software auch die sogenannte Standardsoftware auf. Batch- oder Stapelverarbeitung forderte die spezielle Programmierung für den aktuellen Anwendungsfall. Wenn diese Programme einmal gestartet waren, mussten sie selbstständig bis zum Ende oder zum Abbruch durchlaufen. Anhalten und abwarten, bis der Nutzer irgendeine Entscheidung traf, war nicht sinnvoll, der ganze Rechnerbetrieb hätte auf unbestimmte Zeit stillgestanden. Interaktive Systeme änderten diesen Sachverhalt grundlegend. Die Rechner führten eine Session für jeden Nutzer und wechselten zur nächsten Session, wenn der Nutzer einmal nichts tat, nicht ›interagierte‹. Dadurch konnte die Session der Software auf den Nutzer warten, ohne dass der Rechner seine Arbeit unterbrechen musste. Daher wurde es möglich, allgemeine Software zu schreiben, die den Nutzer fragt, welche Daten verarbeitet werden sollen und wie der Rechner vorgehen solle. Das war die eigentliche Geburtsstunde der Software-Industrie. 293

7.1


Die Hardware der mittleren Datenverarbeitung und die sogenannten Dialogcomputer waren die ersten Geräte, die interaktive Software unterstützten. Die Softwarefirmen, die die Zeichen der Zeit erkannten und auf die neuen Konzepte setzten, wurden die Zugpferde der IT-Revolution. 1969 hatte Peter Kreis, der Chef des Instituts für angewandte Informationsverarbeitung AIV, die Idee, eine Aktiengesellschaft zu gründen (die Software AG), die mit der Entwicklung von Software Geld verdient. Um eine AG zu gründen, waren damals eine Millionen DM erforderlich. Peter Kreis steuerte Software bei, die auf 994.000 DM geschätzt wurde. Die fehlenden 6.000 Mark wurden von verschiedenen Seiten aufgebracht: von seiner Ehefrau Edith Kreis, von Peter Schnell, von der AIV und von weiteren AIV-Mitarbeitern. Der Begriff des Softwarehauses war noch nicht geprägt, und Arbeit gab es nur in Form von Auftragsarbeiten (erste Kunden: die Stadt Wien, TUI und die AEG). Erste eigene Programme konnten nicht verkauft werden, weil sich keine Käufer fanden. So musste nach drei Jahren das Grundkapital durch einen Kapitalschnitt von 10:1 auf 100.000 Mark gesenkt werden, um das Unternehmen zu retten. Zum Glück für das Unternehmen wurde aus Adabas, dem neuen Datenbanksystem von Peter Schnell, ein Renner. Es verkaufte sich vor allem in den USA so gut, dass die Zukunft der Firma gesichert war. In den kommenden Jahren übernahm Schnell nach und nach die Aktienmehrheit und brachte sie schließlich 1992 in zwei Stiftungen ein.

© Software AG

7

Abbildung 7.1

294

Die Software AG in Darmstadt


Heute ist die Software AG mit Sitz in Weiterstadt bei Darmstadt einer der Weltmarktführer für Software zur Steuerung von Geschäftsprozessen. Nach SAP ist es das zweitgrößte Softwarehaus in Deutschland und das fünftgrößte in Europa. Wichtigste Produkte sind Adabas, Natural und webMethods. Schnell brachte damals 98 Prozent der Aktienanteile in die gemeinnützige Software AG – Stiftung mit Sitz in Darmstadt ein. Zu den Aufgaben dieser Stiftung gehören die Förderung von Projekten der Kinder-, Jugend-, Alten- und Behindertenhilfe, außerdem die Unterstützung von Forschung, Wissenschaft und Bildung. »Von seiner Natur her müsste im Wirtschaftsleben der Menschen Brüderlichkeit herrschen, im Unterschied zu Freiheit im Geistesleben und Gleichheit im Rechtsleben. Auch wenn wir offenkundig heute noch weit entfernt sind von dieser bewussten Brüderlichkeit, so muss man erfahrbare Beispiele für die Zukunft der Welt setzen.« – Peter M. Schnell (Software AG-Stiftung) Wie bei der Software AG liegen die Ursprünge der Entstehung auch bei SAP im Bereich der Großrechnersoftware. Hier war es die konkrete Erkenntnis, dass die Zeit der Batchverarbeitung langsam ihrem Ende entgegenging. Es waren fünf Mitarbeiter von IBM in Weinheim (Klaus Tschira, Hasso Plattner, Claus Wellenreuther, Dietmar Hopp und Hans-Werner Hector), die sich 1972 zusammentaten um Realtime-Software, wie sie es nannten, zu erstellen. Realtime deshalb, weil im Batchbetrieb die Ergebnisse für den Nutzer oft sehr lange auf sich warten ließen. Zunächst mussten Lochkarten mit der Anfrage gestanzt werden. Nach mehreren Zwischenschritten erhielt man am Ende Lochkarten mit der Antwort. Im interaktiven System dagegen gab man die Frage am Monitor ein und erhielt dort auch umgehend die Antwort. Aus damaliger Sicht hatte das den Namen Echtzeit (Realtime) verdient. R als Abkürzung für Realtime blieb über viele Jahrzehnte Bestandteil von Software-Systemnamen bei SAP, so z. B. R3. Weil man noch nicht über eigene Hardware verfügte, wurde das erste Produkt im Rechenzentrum des Kunden entwickelt. Das war das Rechenzentrum der ICI (Imperial Chemical Industrie). Da man diese Software von Anfang an als Standardsoftware konzipiert hatte, konnte sie bald darauf an mehrere andere Interessenten verkauft werden. Daher gilt SAP auch als Miterfinder der Standardsoftware. Außerdem entwickelte man schon früh ein Modulkonzept, das auf einer Datenbasis in der Datenbank aufbaute und verschiedenste Anwendung miteinan-

295

7.1


der verzahnte, ohne dass Daten hin- und hergeschoben werden mussten. Man internationalisierte die Software sehr früh, indem man Verweise auf Tabellenzeilen einführte, in der die jeweiligen Begriffe in Landessprache standen. Partnerfirmen konnten so sehr einfach die Software an jede gewünschte Sprache anpassen.

© SAP

7

Abbildung 7.2

SAP Locations St. Leon-Rot, Building 22

1976 gründete man die SAP GmbH, aus der 1988 die SAP Aktiengesellschaft, Systeme, Anwendungen und Produkte in der Datenverarbeitung wurde. Die Abkürzung SAP wurde erst 2005 durch einen Beschluss der Hauptversammlung zum offiziellen Namen der Aktiengesellschaft. Hauptprodukt von SAP ist die SAP Business Suite.

7.1.2

Das große Artensterben

Die Zahl der Softwareanbieter war in den 70er und 80er Jahren wesentlicher höher als heute. So hat es auch kaum eine Branche gegeben mit einer derartig hohen Anzahl an Firmenübernahmen wie die Softwarebranche. Das gilt für kleine wie große Unternehmen gleichermaßen. Einer der ganz Großen ist immer noch CA (Computer Associates). 1976 in New York von Charles B. Wang mit drei Kollegen gegründet, entwickelte man erst Tools und Programme für IBM-Großrechner. Die Software hatte durchweg einen sehr guten Ruf, und so gelang es der CA Inc. – wie die Firma seit 2004 heißt – als Nischenanbieter, auch die schwereren Zeiten zu überdauern. Heute liefert man Projektmanagement und Manage-

296


© CA

ment-Programme für die Speicher- und Netzwerkverwaltung. Den Firmensitz hat das Unternehmen in Islandia im Bundesstaat New York.

Abbildung 7.3

Cloud-Seite der CA – (http://www.ca.com/us/cloud-computing.aspx)

Die größten Wechselbäder in der Firmengeschichte erlebte zweifellos IBM. Aus der 1896 von Hollerith gegründeten Tabulating Maschine Company hervorgegangen, standen die drei Buchstaben in den Großrechnerzeiten förmlich für den Computer schlechthin. Die Entstehung des Weltunternehmens war zum großen Teil die Arbeit eines Mannes, der 1943 den Satz sagte: »I think there is a world market for maybe five computers.« (»Ich denke, es gibt einen Weltmarkt für gerade mal fünf Computer« – allein 1952 hatte man bereits 18 Maschinen des Typs IBM 701 verkauft.) Dieser Mann war Thomas J. Watson, seit 1914 der Chef der Computing Tabulating Recording Corporation, eines der Unternehmen, aus denen IBM hervorging. Er leitete IBM erfolgreich bis 1955. Rechner wurden in der Regel nicht verkauft, sondern vermietet, ebenso die Software. Ein Großteil der Einnahmen stammte aus den daraus resultierenden Wartungsverträgen. Mit dem Aufkommen der standardisierten Rechnersysteme, die man mitentwickelt hatte, wurde die Verwendung von Betriebssystemen nötig.

297

7.1


Teilweise ließ man sie entwickeln, teilweise entwickelte man sie selbst und schuf sich damit früh ein zweites Standbein im Softwaremarkt. Bis heute ist die meiste Software zugekauft oder durch Firmenübernahmen erworben.

© IBM

7

Abbildung 7.4

Homepage von IBM (http://www.ibm.com/us/en/)

Die Existenzkrise begann für IBM, als Apple den Microcomputer Apple II auf den Markt brachte. Schon wurde der Tod des Großrechners vorhergesagt. In der Tat gingen die Großrechnerverkäufe seitdem stetig zurück. IBM konterte mit dem IBM-PC und schuf damit das erfolgreichste Computermodell aller Zeiten. Den großen Gewinn fuhren jedoch die Clone-Produzenten aus Fernost ein. Mit dem IBM-DOS wurde auch das erforderliche Betriebssystem geliefert, das man bei Microsoft zugekauft hatte. Es sollte später durch das fensterorientierte Betriebssystem OS/2, das man gemeinsam mit Microsoft entwickelt hatte, ergänzt und schließlich ersetzt werden. OS/2 konnte sich auf Dauer nicht behaupten, genauso wenig wie Original-PCs von IBM. Man versuchte sich in zahlreichen Softwareprogrammen, unter anderem dem CAD-System Catia, das in Lizenz vertrieben wurde.

298

Wie PowerPoint erfunden wurde

Das erfolgreichste Softwareprodukt von IBM ist Lotus Notes, das durch die Übernahme der Firma Notes 1996 zu IBM kam. Mit vier Milliarden Dollar war es bis dato die teuerste Übernahme einer Softwareschmiede.

7.2


Whitfield Diffie, ein ziemlich abgehalfterter 68er, der aussah, als erhielte er Geld von seinem Friseur, damit er den Leute vorführte, wie wichtig dieser Berufszweig war, war Kryptologe. Und auf diesem Gebiet war er einer der Besten. In der Zeit, als er für Bell Nothern arbeitete, musste er oft lange Vorträge halten und benötigte dafür große Mengen an Overheadfolien. Damals wurden diese Folien von Hand gezeichnet. Damit sie nicht wie an die Wand geworfene Schmierereien aussahen, musste man dafür sehr viel Zeit aufwenden. Also setzte er sich 1975 kurzerhand hin und schrieb ein Programm, mit dem er die Folien am Computer entwerfen und auf sehr dünnes, durchscheinendes Papier drucken konnte. Das war zwar noch keine Patentlösung, aber sein Chef Bob Gaskins kam in einem dieser Vorträge der Gedanke, dass auch andere Leute Vorträge halten müssten und solche Grafiken brauchten. Also setzte er sich ebenfalls hin und schrieb ein Programm, das er Presenter nannte. Der Name war allerdings bereits vergeben und so entschied er sich 1984 für die Bezeichnung PowerPoint (»starkes Argument«). Seine Farbversion, die er 1987 auf den Markt brachte, war so erfolgreich, dass er dadurch Millionär wurde. Noch im gleichen Jahr verkaufte er seine Firma für 14 Millionen an Microsoft. Dort sorgt seine Programmidee noch heute für Umsatz. Microsofts wichtigstes Standbein war von Anfang an das Geschäft mit Betriebssystemen. Bill Gates hatte damals für den PC das System PC-DOS geliefert und damit einen der Grundsteine für seine Firma gelegt (siehe Abbildung 7.5). Zusammen mit Betriebssystemen werden oft auch viele Anwendungsprogramme geliefert, so entwickelte man auch solche Produkte oder kaufte sie zu. Die Idee von Windows hatte man im Xerox-Labor kennengelernt und erkannt, dass dies der richtige Weg war, nutzerfreundliche Software zu entwickeln. Neben der reinen Oberfläche gab es bei Xerox aber auch schon Anwendungen, die auf dieser Oberfläche liefen. Unter anderem ein Textverarbeitungsprogramm namens Bravo, das den Text statt in grüner Schrift auf schwarzem Hintergrund ansatzweise so zeigte, wie er auf dem Papier am Ende aussah. Der Entwickler dieser Textverarbeitung, Charles Simonyi, wechselte 1981 von den Xerox-Labors zu Microsoft und leitete dort die Entwicklung der ersten Word-Version für DOS auf reiner Textbasis. Sie ging 1983 in den Handel. Aber bereits 1984 folgte eine Ver-

299

7.2


sion für den Apple Mac mit seiner grafischen Oberfläche. Das erste Word für Windows erschien 1989 und kostete übrigens rund 500 $.

© Microsoft

7

Abbildung 7.5

Der Microsoft-Gründer auf einer Senatsanhörung

Daneben hatten sich auch andere Programme etabliert, wie das Tabellenkalkulationsprogramm Excel oder das eben erwähnte PowerPoint. MS dachte daran, sie in einem Gesamtpaket zusammen zu lassen. Die sogenannten integrierten OfficePakete hatten ab 1983 begonnen, sich am Markt durchzusetzen. Das waren Programme wie SPI Open Access, Framework von Ashton-Tate, Novell Works und Symantec F&A. Während diese Programme über interne Schnittstellen verfügten, baute Microsoft auf die Zwischenablage von Windows und ließ die Programme getrennt, verkaufte sie aber als Office-Paket. »MS-DOS ist unsere innovativste Entwicklung.« – Bill Gates Die allererste Version von Microsoft Office mit Word, Excel und PowerPoint gab es 1989 nicht für Windows, sondern ausschließlich für den Macintosh, einen Apple-Rechner. Am 30. August 1992 erschien es das gleiche Programmpaket für Windows 3.1, das im März auf den Markt gekommen war. Im Mai 1993 wurde das Office-Paket um die Datenbanklösung Access erweitert. Sie wird allerdings bis heute nicht für das Apple-Office-Paket angeboten. Inzwischen gibt es die Version MS Office 2010 – es ist nach wie vor das meistverkaufte Office-Paket und damit einer der Garanten für den Erfolg von Microsoft. Was nicht heißt, das Microsoft nicht mehr Software zu bieten hätte. Ein weiteres Schwergewicht ist eindeutig der Internet Explorer, von dem man immer noch

300


nicht genau weiß, ob er nun zu Windows gehört oder nicht. Weil Microsoft ihn bei Windows immer mitgeliefert hatte, kam es zum Browserkrieg und zu Prozessen, die Microsoft meist verlor. Neben Windows selbst ist der Internet Explorer das bekannteste Microsoft-Produkt. Er wurde ab 1993 nach dem Beispiel des NCSA Mosaic Browsers entwickelt. Die aktuelle Version ist die Nummer 8. Zurzeit hat er noch immer einen Marktanteil von knapp unter 60 %, Firefox liegt bei 25 %, und Google Chrome konnte bis auf 7 % ansteigen. Microsoft hat viele weitere, meist kleinere Programme entwickelt und verkauft, selbst an Hardwareprojekte hat man sich herangetraut. Erfolgreiche Beispiele sind die Microsoft Mouse und die Xbox, weniger erfolgreich war der Microsoft Tablet PC.

7.2.1

Kennen Sie »Bob«?

Eins der ungewöhnlichsten Softwareprojekte bei Microsoft war zweifellos Bob, eine andere grafische Oberfläche für Windows, die unter der Leitung einer gewissen Melinda French, ihres Zeichens Programmiererin, entwickelt wurde. Wer Bob nicht wenigstens einmal gesehen hat, kann es sich kaum vorstellen. Deshalb hat man sich bei Winhistory die Mühe gemacht, dieses System auf einer Webseite zu simulieren:

Abbildung 7.6

Bob in Bill Gates Wohnzimmer???

301

7.2

7


Man hatte nämlich festgestellt, dass sich trotz der grafischen Oberfläche von Windows viele Leute damit nicht zurechtfanden. Das lag zum Teil aber auch daran, dass um 1995, als Bob herauskam, die Zeit der reinen Computerfreaks langsam zu Ende ging. Immer mehr ältere Semester begannen, sich privat für den Computer zu interessieren, auch weil der Preis der kompatiblen PCs so weit gesunken war, dass der Standardhaushalt ihn sich leisten konnte. Die Idee war, die Oberfläche mehr wie eine Alltagsumgebung zu gestalten, um sich einfacher darin zurechtfinden zu können. Windows sollte zu einem Wohnhaus werden, das man durch eine Tür betreten konnte. Verschiedene Räume sollten ihrer Bestimmung nach entsprechende Software präsentieren: das Büro, die Textverarbeitung und eine Tabellenkalkulation, E-Mail u. Ä. Animierte Figuren sollten ihre Dienste anbieten und Auskunft erteilen, wenn etwas unklar sein sollte. Von der Idee her nicht schlecht wurde das Produkt jedoch ein buntes Allerlei, dessen Bedienung langatmig und umständlich ist. Melinda French wäre vielleicht mit dem Projekt untergegangen, wenn sich nicht zarte Bande gesponnen hätten. Als Bob fertig war, hieß sie nicht mehr French, sondern Gates und war die Frau eines der reichsten Männer der Welt. Böse Zungen behaupten, ohne diesen Umstand wäre Bob nie auf den Markt gekommen. Wie auch immer, es wäre schade gewesen, denn eines ist Bob bestimmt: originell. Wer sehen möchte, ob MS nicht irgendwann wieder etwas ähnlich Buntes im Programm haben wird, kann sich über die neuesten Forschungen bei Microsoft informieren und folgende Seite besuchen: http://research.microsoft.com/en-us/ default.aspx

7.2.2

Ein Riese stolpert

Der Dozent hatte den Computerraum tags zuvor vorbereiten lassen. dBASE IV, die neueste Version des weltweit erfolgreichsten Datenbankprogramms von Ashton-Tate war zwei Tage zuvor eingetroffen und frisch installiert worden (siehe Abbildung 7.8). Es sollte das erste praktische Seminar für diese Studentengruppe werden. Eine Stunde, wie viele andere zuvor, und es schien ein normaler Tag an der Fachhochschule zu werden. »Herr Denz, mein PC ist gerade abgestürzt, was soll ich tun?«, schimpfte Kurt Jung. Natürlich kam so etwas öfter vor. Aber als die ersten Daten in die frisch angelegten Dateien geschrieben werden sollten, ging es reihum. Denz begann sich am

302


Kopf zu kratzen. Sollte das neue System nicht richtig installiert worden sein? Denz erklärte kurz das Regiezentrum, einen Teil des Programms, von dem aus man die zahlreichen Funktionen aufrufen konnte. Allerdings stellte sich heraus, dass kaum jemand mit der Oberfläche dieses Programmteils zurechtkam. Zudem war alles, was dBASE IV ausführen sollte, mit quälend langen Wartezeiten verbunden. Je weiter der Unterricht fortschritt, desto chaotischer wurde es. Schließlich musste Herr Denz den praktischen Unterricht abbrechen und im Hörsaal das Ganze an der Tafel durchsprechen. Das ist genau so passiert, denn ich selbst saß mitten unter den Studenten; die Namen wurden natürlich von mir geändert. Aber was war wirklich los? dBASE war damals auf dem PC das erfolgreichste und am weitesten verbreitete Datenbanksystem. Doch Ashton-Tate hatte mit der vierten Version einen schweren Fehler gemacht. Statt das Produkt solide weiterzuentwickeln, hatte man es mit neuen Funktionen vollgepackt, SQL als Datenbanksprache mit aufgenommen und die Termine für den Verkaufsstart viel zu knapp bemessen. Nach einer ersten Verschiebung des Termins wollte man es dann den Kunden unbedingt zur Verfügung stellen. Es wurde ohne die erforderlichen und sehr zeitaufwendigen Lasttests auf den Markt geworfen. Das war der Anfang vom Ende von Ashton-Tate. Wenige Monate später übernahm Borland das finanziell völlig zusammengebrochene Unternehmen für 439 Mio. $. Es gelang dBASE nie mehr, den verlorenen Marktanteil zurückzuerobern. Microsoft hatte sich längst mit seinem Access genannten Datenbanksystem in die entstandene Lücke gedrängt. Ashton-Tate war im Januar 1980 von George Tate und Hal Lashlee unter dem Namen Software Plus, Inc. (SPI) als Softwarehändler gegründet worden. Die Software wurde erst in einer Garage versandfertig gemacht. Danach wurden Zimmer in den Wohnhäusern mit Beschlag belegt. Es ging langsam, aber stetig aufwärts, bis ein Kunde ein Datenbankprogramm namens Vulcan orderte. Tate und Lashlee machten sich auf die Suche.

© Michael Jeschio; http://de.wikipedia.org

Abbildung 7.7

Das Emblem des gefallenen Riesen

303

7.2

7


Die Geschichte von dBASE selbst ist eine Nummer älter, als die von Ashton-Tate. Sie beginnt bereits in den 60er Jahren. RETRIEVE war die marktbeherrschende DB-Software von Tymshare, Inc. für Großrechnersysteme. Das Jet Propulsion Laboratory (JPL) – es baute u.a. Raketenantriebe für die NASA – war eines der Hauptnutzer und ließ sich das System speziell von einem Jeb Long anpassen. Nun lief RETRIEVE auf dem UNIVAC 1108 des JPL und hatte synonym den Namen JPLDIS (Jet Propulsion Laboratory Display Information System). Ein gewisser Wayne Ratliff lernte das Datenbanksystem dort kennen und kam auf eine verrückte Idee. Er gehörte zum Viking-Programm der NASA und hatte für die Mars Viking Lander ein Datenbanksystem namens mFile entwickelt. Im Büro wettete man leidenschaftlich auf die Football-Ergebnisse, und er war es leid, immer den Kürzeren zu ziehen. Was, wenn er die Mannschaften in einem Datenbankprogramm gegenüberstellte? Angeregt durch das JPLDIS setzte er sich hin und schrieb in Assembler ein eigenes DB-System für seinen CP/M-Computer. Als eingefleischter Star-Trek-Fan nannte er es Vulcan, nach dem Heimatplaneten des spitzohrigen Mr. Spock. Weil sich der Wetterfolg nicht so recht einstellen wollte, kam er auf die Idee, Kopien des Programms für 50 $ zu verkaufen. Es verkaufte sich ganz gut, und so wurde ihm bald die Kopierarbeit und der Versand zu viel, so dass er den Vertrieb wieder einstellte. Inzwischen sprach sich jedoch unter den Computeranwendern herum, dass es dieses DB-System gab, und so wurden Tate und Lashlee darauf angesprochen. Sie machten Wayne Ratliff auch ausfindig und konnten ihn dazu überreden, den Vertrieb 1980 an sie abzutreten. Damit Ratliff weiter seine 50 $ bekam, setzte man den Preis auf 695 $ fest und nannte das Programm dBASE II. Es wurde ein großer Erfolg, nicht nur deshalb, weil man es gleich als zweite Version herausbrachte, da man der Meinung war, eine erste Version ließe sich nicht verkaufen. dBASE wurde bald darauf von CP/M auf PC-DOS übertragen. 1983 kaufte man die Gesamtrechte an dBASE von Ratliff und stellte ihn als Entwicklungschef ein. Außerdem firmierte in diesem Jahr das Softwarehandelshaus SPI um in Ashton-Tate. Richtig erfolgreich wurde Ashton-Tate letztendlich mit dBASE III und dBASE II Plus. Allein in Europa kam man bei den PC-Datenbanksystemen auf einen Marktanteil von 67 %. Der Hauptkonkurrent hieß damals PARADOX und war eine Datenbank von Borland. Neben dBASE hatte man auch ein Integriertes Softwarepaket im Programm, das unter einer Oberfläche Datenbank, Tabellenkalkulation, Textverarbeitung und Programmierung bot. Es nannte sich Framework und war das Konkurrenzprodukt zu Lotus Symphony und SPI Open Access.

304


Abbildung 7.8

dBASE IV-Hilfeseite

Praxis: Lotus Symphony Integrierte Softwarepakete lieferten das Muster, nach dem Microsoft sein OfficePaket strickte. Ein solches Paket enthielt alles, was man für die tägliche Büroarbeit braucht – wie es bei MS Office heute noch ist. Von dem alten Klassiker gibt es jedoch kaum noch Versionen, die auf den aktuellen Betriebssystemen laufen, bis auf ganz wenige Ausnahmen. Eine davon nennt sich Lotus Symphony. Auch die Übernahme durch IBM hat die Software gut überstanden. Unter dem neuen Dach wurden auch neue Ideen geboren, und so ist dieses Programmpaket zwar ein Nischenprodukt, aber trotzdem aktueller denn je. Die neueste Version kann man sich über die Produkt-Webseite downloaden: http://symphony.lotus.com/software/lotus/symphony/home.nsf/home. Die mir vorliegende Version war Lotus Symphony 3 Beta 3 (siehe Abbildung 7.9). Die Version 3 hat als Entwicklungsbasis das Eclipse-Framework und als Vorbild die OpenOffice-Software. Wer ein neues Office-Paket benötigt oder sich für ein solches interessiert, sollte sich einmal die Mühe machen, diese Software herunterzuladen. Für den Programmierer interessant ist, dass sie in Java programmiert und wie Eclipse mit Hilfe von Plugins erweiterbar ist. Zusätzlich gibt es eine Entwicklerversion, die ebenfalls von der Download-Seite geladen werden kann: Lotus Symphony 3 Beta (IBM Lotus Symphony 3 Beta 3 – Developers Toolkit).

305

7.2

7


Abbildung 7.9

Lotus Symphony mit dem Buchtext

Die Lotus Development Corporation war 1982 von Mitch Kapor und Jonathan Sachs in Cambridge, Massachusetts, gegründet worden, um Software für die neuen Microcomputer zu entwickeln und zu verkaufen. Deshalb war das erste Produkt »Lotus Executive Briefing System« auch für den Apple II. Wirklich erfolgreich wurde die Firma ab 1983 mit der ersten modernen Tabellenkalkulation, dem Programm Lotus 1-2-3. Wie der Name Lotus, der an die 68er erinnert, vielleicht schon vermittelt, war das Unternehmen immer sehr mitarbeiterfreundlich. 1995 wurde es von IBM zu einem Preis von 3,5 Milliarden $ übernommen. Auch die Firmenpolitik wurde teilweise mit übernommen. »Wenn Sie sich ein Haus bauen lassen, sprechen Sie mit einem Architekten und nicht mit einem Ingenieur. Warum ist das so? Was ein gutes Haus ausmacht, fällt eher in den Bereich eines Designers als in den eines Technikers.« – Mitch Kapor

306

Es muss nicht immer Microsoft sein

7.3


Einer der ganz großen Player im Softwaregeschäft neben IBM ist Oracle. Mit der Übernahme von Sun hat man sich zu einem Full-Service-Anbieter gemausert. Vom Hochleistungsrechner bis zum Datenbankprogramm hat Oracle nun fast alles in der Palette, was im IT-Bereich gefragt ist. So ist man zum einzigen echten Gegenspieler von IBM geworden.

7.3.1

König der Datenbanken

Die Entstehung des Unternehmens reicht bis ins Jahr 1977 zurück. Damals wurde es von Bob Miner, Larry Ellison und Ed Oates als SDL (Software Development Laboratories) gegründet. Man entwickelte eine relationale Datenbank mit dem Namen Oracle, als Assoziation zum Orakel von Delphi, das einst auch Anfragen beantwortete. Dem Abnehmer, der CIA, war der Name wohl ebenfalls genehm. Entsprechend dem Einsatzgebiet war das System für umfangreiche Datenmengen geplant. Nach dem Ausliefern der ersten Version zog man nach Menlo Park in Kalifornien um und änderte den Firmennamen auf RSI Relational Software, Inc. Nach der Veröffentlichung von Oracle V3, das ganz in C neugeschrieben worden war, nahm man schließlich 1983 den Firmennamen Oracle an. Das Produkt war inzwischen weit bekannter als der Hersteller, und so konnte man von der Popularität profitieren, als man am 15. März 1986 an die Börse ging.

© Oracle

Noch einmal wechselte das Hauptquartier von Oracle den Standort, man ging 1994 nach Redwood Shores. Oracle übernahm während der gesamten Firmengeschichte zahllose Unternehmen. Trotzdem war es eine Sensation, als 2009 man bekannt gab, Sun Microsystems für 7,4 Milliarden $ kaufen zu wollen.

Abbildung 7.10

Oracle-Hauptquartier in Redwood Shores

307

7.3

7


Nachdem am 21. Januar 2010 auch die EU-Kommission die Übernahme kritiklos genehmig hatte, war sie so gut wie perfekt. Seitdem ist Sun Teil des Oracle-Konzerns. Die Nutzer und Entwicklergemeinde hat die Übernahme nicht ganz so kritiklos hingenommen. Das rührt in erster Linie daher, weil Sun zahlreiche OpenSource- und Freeware-Produkte besaß und auch unterstützt hatte. Dazu zählten vor allem Java, MySQL und OpenOffice. Oracle ist nicht ganz so freizügig mit seiner Lizenzvergabe, wie es Sun war, so ist zu erwarten, dass einige der Produkte früher oder später ihren Kostenlos-Status verlieren werden. Praxis: Oracle Das Oracle-Datenbank-Managementsystem kann als Express-Edition (XE) für private Anwender zu Lernzwecken kostenlos genutzt werden. Allerdings ist das System sehr umfangreich, und wenn man sich ernsthaft damit auseinandersetzen möchte, muss man einiges an Zeit investieren. Deshalb soll diese Möglichkeit hier auch nur kurz erwähnt sein. Die Webseite ist folgende: http://www.oracle.com/technology/software/products/ database/index.html Nach der Unternehmensgründung 1977 war der erste Angestellte Bruce Scott; er hatte eine Katze namens »Tiger«. Daraus entstand der Benutzername »scott« mit dem Passwort »tiger« für einen heute noch gern eingesetzten Demo-User.

7.3.2

Ein Stern am Computerhimmel

Das war sehr ärgerlich: Die Anzeige der Nachbarn beim Ordnungsamt wegen des Betriebs eines Unternehmens in einer reinen Wohngegend konnte das Aus bedeuten. Marco Börries, 17 Jahre alt, hatte zwar die Schule abgebrochen, aber leicht aufgeben, das gab es bei ihm nicht. Die Schule hatte er schließlich an den Nagel gehängt, um mit Hilfe des Computers Millionär zu werden. Außerdem hatten 1984 seine Eltern ihre Arbeit gekündigt und waren bei ihm eingestiegen – bei seiner Firma, der Star Division in Lüneburg. Deshalb musste es einfach weitergehen. So wurde kurzerhand der Firmensitz nach Hamburg verlegt. Sein Vorhaben war so verrückt wie genial. Microsofts Office-Paket war eines der meistverkauften Programme überhaupt, weil dessen Teilprogramme die alltägliche Arbeit im Büro optimal unterstützten. Es gab Textverarbeitungs-, Tabellenkalkulations-, Datenbanks- und Präsentationsfunktionen. Das ließ sich Microsoft richtig gut bezahlen. Wenn man es schaffte, ein Konkurrenzprogramm zu programmieren, es aber billiger anbot, konnte man damit richtig Kohle machen. Und genau das machte Marco Börries mit seiner Firma Star Division.

308


Ein Jahr später machte er bereits Millionenumsätze. Die StarOffice-Suite wurde weltweit insgesamt weit über 25 Millionen Mal verkauft.

Abbildung 7.11

StarOffice 4.0 als OEM-Version

IBM sprach den Jungunternehmer an, man wollte StarOffice für das Betriebssystem OS/2. Ein Vorvertrag wurde gemacht. 1995 entschloss sich IBM jedoch, die Firma Lotus hauptsächlich wegen ihres Groupware-Pakets (Lotus Notes) per feindlicher Übernahme zu kaufen. Da Lotus mit Symphony bereits eine OfficeSuite im Repertoire hatte, war man nun an Star Division nicht mehr interessiert. IBM blieb nichts anders übrig, als sich aus dem Vorvertrag rauszukaufen. Angeblich sind dabei 30 Millionen $ geflossen. Noch mehr Millionen gab es, als der 31-jährige Börries Star Division 1999 an Sun verkaufte (angeblich lag der Kaufpreis bei 59,5 Mio. $). Kontakte gab es schon länger. Andreas von Bechtolsheim, einer der Sun-Gründer, hatte sich bereits 1992 an dem Hamburger Softwarehaus beteiligt. Das StarOffice-Paket war damals eines der innovativsten Softwareprodukte am Markt. Es baute auf einem eigenen Framework auf und war ganz in OOP erstellt. Außerdem gab es damals bereits eine Webversion des Office-Pakets. Das heißt, man konnte über einen Browser seine Büroarbeit erledigen, ohne an einem Rechner mit installierter Office-Software zu sitzen. Damit war StarPortal die erste größere Cloud-Anwendung. Mit der Firma hatte Sun auch Marco Börries als Vizepräsident für Applikationssoftware übernommen. Er blieb jedoch nur zwei Jahre Mitarbeiter bei der Firma aus Santa Clara und gründete nach der Kündigung 2001 das Unternehmen Verdisoft, um Handys Suchmaschinen und andere Internetseiten schmackhaft zu machen.

309

7.3

7


Bereits 1997 hatte Börries mit Sparkassen zusammen die Banking-Softwarefirma Star Finanz ins Leben gerufen. Sie war nicht Teil des Sun-Deals. Zusammen mit den Sparkassen entwickelte man StarMoney, das erfolgreichste OnlinebankingSystem Europas. Fast alle deutschen Banken bieten ihren Kunden dieses Paket fürs Onlinebanking an. Die Firma samt ihres Star-Produktes ist heute noch erfolgreich (siehe Abbildung 7.12).

Abbildung 7.12

StarMoney-Homepage – http://www.starmoney.de/

Kurz nachdem er Sun verlassen hatte, verkaufte Marco Börries auch seine StarFinanz-Anteile an die Miteigentümer dvg (Hannoversche Datenverarbeitungsgesellschaft) und den IT-Dienstleister IZB Soft. Die neue Firma Verdisoft überzeugte den Suchmaschinenbetreiber Yahoo so sehr, dass er sie 2005 für 60 Millionen Dollar kaufte, ohne dass sie überhaupt ein konkretes Produkt hatte. Auch dieses Mal wurde er vom Käufer eingestellt, und zwar als Senior Vice President Connected Life. Er verkaufte den Rohbau seines Traumhauses an der Elbe und lebte anschließend größtenteils in Kalifornien. Doch bereits Ende April 2009 gab er auch diese Stelle auf und verlegte seinen Wohnsitz wieder ganz nach Deutschland. Am 1. September 2009 startete Börries eine neue Firma. Sie heißt sinnträchtig NumberFour AG und hat ihren Sitz in Berlin. Geschäftsfeld des Unternehmens ist

310


all das, was man heute unter dem Begriff Cloud Computing zusammenfasst. Bleibt abzuwarten, wie viel Erfolg ihm diesmal beschieden ist.

Abbildung 7.13

Homepage der NumberFour AG – http://numberfourag.wordpress.com/

Bei unseren Ausführungen wurde der Name Borland bereits öfters erwähnt, deshalb soll hier kurz auch auf diese Firma eingegangen werden. Es ist eine Legende, dass die Programmiersprache Pascal deshalb in der Ausbildung und an den Schulen so intensiv genutzt wurde, weil TurboPascal von Borland die beste Implementierung der Sprache war und Borland 1983 von einem nach Amerika eingewanderten Mathematiklehrer gegründet wurde. Der Lehrer namens Philippe Kahn hatte die Firma gegründet, um Entwicklerwerkzeuge, also Compiler, Linker, Debugger, für Microcomputer zu entwickeln und zu vertreiben. Der Entwicklungsprozess war damals noch sehr umständlich und bestand aus zwei Compilerläufen, und dem Linkerlauf. Außerdem musste man den Editor verlassen, um die Software bauen zu können. Mit der Idee, eine IDE, eine spezielle Entwicklungsumgebung, zu erstellen, von der aus man die einzelnen Schritte aufrufen und im Hintergrund ablaufen lassen konnte, öffnete sich für Borland eine Goldgrube. Viele Jahre waren die Borland-Produkte erfolgreicher als die Entwicklerwerkzeuge von Microsoft. Doch nach und nach gerieten sie ins Hintertreffen. Das lag zum Teil an den besser werdenden Microsoft-Pro-

311

7.3

7


dukten und hier insbesondere an Visual Basic, zum Teil hatte sich Philippe Kahn aber auch übernommen, weil er neben den Entwicklungsprogrammen auch Businessapplikationen und weitere Produkte anbot. In finanzielle Schwierigkeiten geraten, wurden einige Produktreihen und Firmenteile verkauft – so die TurboProdukte beispielsweise an Embarcadero. Am 27. Juli 2009 war schließlich die Übernahme der Firma Borland Software durch die Firma Micro Focus abgeschlossen.

7.3.3

Novell

Novell entstand im CP/M-Boom der Anfangszeit der Microcomputer-Systeme. Gegründet wurde Novell in Provo, Utah, als Novell Data Systems Inc. im Jahre 1979. Die Firma war damals ein reiner Hardwarehersteller für CP/M-Rechner und ihre Bauteile. Die Gründer waren George Canova, Darin Field und Jack Davis. Das kleine Unternehmen schaffte es nicht, mit seinen Hardwareprodukten auf eine sichere finanzielle Basis zu kommen. So mussten neue Finanziers gesucht werden für die Pläne, die Hardware aufzugeben und als Softwareanbieter weiter zu wirtschaften. Man hatte Führungskräfte, die vorher bei der ARPA gearbeitet hatten und sich gut mit Datenübertragung und Netzwerken auskannten. Es lag also nahe, etwas in diese Richtung zu entwickeln. Bereits 1983 konnte man eine Neuheit vorstellen, das Netzwerk-Betriebssystem NetWare. NetWare war für viele Plattformen verfügbar und regelte die Datenübertragung über das Netzwerk für Betriebssysteme, die normalerweise nicht mit Netzwerken umgehen konnten. Dabei stellte NetWare einen Verzeichnisdienst, Dateifreigaben und Druckerzugriffe über das Netzwerk her. Damit war es zwar kein Rechner-Betriebssystem, aber ein Aufsatz, der Netzressourcen in die Funktionalität der verwendeten Betriebssysteme überführte. Damit war man in den 80er Jahren Monopolist, was Netzwerke anging, und konnte die Produktpreise nach Ermessen diktieren. Als sich jedoch Netzwerke immer mehr etablierten, kamen Anbieter hinzu: Sun und Apple mit PC-NFS, das nur einen Dateizugriff über Rechnergrenzen hinweg realisierte, schließlich Windows mit seinen Serverversionen und Linux. Diese Systeme waren echte Betriebssysteme, die noch weiter gingen als NetWare und neben Daten auch Rechenleistung über das Netz zur Verfügung stellen konnten. Unaufhaltsam begann die Marktmacht Novells mehr und mehr zu schwinden. Novell kämpfte ums Überleben. Mit Zukäufen und Übernahmen versuchte man

312

Nicht umsonst, aber Open Source

die Produktpalette zu verbreitern. 2001 kaufte man das Unternehmen Cambridge Technology Partners, um es für den Verkauf der eigenen Produkte zu nutzen. Mit der Übernahme der deutschen SuSE Linux AG im Jahr 2003 für 210 Mio. $ hievte man sich aus der Netzwerkklemme und wurde zum echten Betriebssystemanbieter. SuSE wurde in eine GmbH umgewandelt und vollständig in Novell integriert. Somit ist Novell einer der größten Anbieter auf dem Open-Source-Linux-Markt geworden. Zum Thema Software hat sich seit vielen Jahren die Einstellung verbreitet, dass Software eigentlich Gemeingut ist, also niemanden wirklich gehört und kostenlos abgegeben werden sollte. Für diese Idee steht der Begriff Open Source.

7.4


Als die Zeit der Homecomputer anbrach, wurde das Interesse an der Programmierung so groß, dass viel mehr Programme geschrieben wurden, als man überhaupt benötigte. Gleichzeitig sank die Qualität der häufig von Freizeitprogrammierern erstellten Software stark ab. Was daraus resultierte, war, dass viele Programmierer zwar nicht unbedingt schlechte Programme schrieben, sie aber nicht loswurden. Da Software, wenn man sie aufbewahrt, zwar nicht schlecht wird, aber schnell veraltet, weil sich die potentiellen Nutzer nach und nach neue Rechner kaufen, auf denen gerade diese Software nicht mehr läuft, ist es wichtig, ein Softwareprodukt direkt nach der Fertigstellung zu verkaufen. Als dies mit Preissenkungen nicht mehr möglich war, verfiel man auf die Idee, die Software erst einmal kostenlos zu verleihen, bis der potentielle Nutzer nicht mehr auf sie verzichten wollte und sie freiwillig bezahlte. Die sogenannte Shareware war erfunden. Sie hatte nur einen Nachteil: Die potentiellen Nutzer zahlten nur manchmal. Schließlich konnte der Autor der Software nicht kontrollieren, wer sich die Software besorgt hatte. Zu diesem Überangebot ohnehin billiger Software kam noch das Treiben der Hacker, die legal gehandelte, teure Software kopierten und per Tausch verbreiteten, so dass die kommerziellen Softwareentwickler ebenfalls stark geschädigt wurden. In Amerika herrscht das Prinzip des common law, das besagt, dass man für eine Tat nicht mehrfach bestraft werden darf. Genauso wenig dürfen mit öffentlichen Geldern erstellte Produkte noch einmal verkauft werden, sie gehören der Allgemeinheit und dürfen nicht privatisiert werden. Da auch sehr viele Unis und For-

313

7.4

7


schungseinrichtungen Software entwickelten, durfte diese nicht verkauft werden. Man gab sie ebenfalls kostenlos ab, ohne die Rechte daran abzutreten. Somit war die Public Domain entstanden, die gemeinfreie Software. Beide Arten der Software nahmen an Qualität zu, weil auch die Werkzeuge, Compiler und Linker, IDEs und Debugger von der Community entwickelt wurden und kostenlos weitergereicht, aber auch beständig verbessert wurden. Man lernte halt dazu.

7.4.1

»GNU is not UNIX«

1984 kam ein gewisser Richard Stallman auf die Idee, etwas Größeres in Angriff zu nehmen. Er dachte hierbei an UNIX. Das war im August 1969 in den Bell Laboratories, dem Forschungslabor von AT&T, einem der größten und erfolgreichsten Entwicklungsinstitute der Welt, entwickelt worden. Dort hatte man immerhin schon den Transistor und die Solarzelle erfunden. Ken Thompson programmierte die erste Version noch in Assembler für eine DEC PDP-7 als Ersatz für das damals genutzte Betriebssystem Multics. Ein gewisser Dennis MacAlistair Ritchie stieß dazu und entwickelte mit ihm ein Spiel, um die Möglichkeiten des Systems auszuloten. Gemeinsam mit Brian W. Kernighan entwickelten sie die Sprache C und begannen damit, das System neu zu implementieren. Schließlich verteilten sie es kostenlos mitsamt dem benötigten C-Compiler an zahlreiche amerikanische Universitäten. Dort wurde es erweitert und verbessert. So entstand die Berkeley Software Distribution, kurz BSD genannt. AT&T versuchte aber auch selbst, das System zu vermarkten – was die Studenten, die sich als Mitentwickler fühlten, nicht gut fanden und was Stallman mit zu seinem Vorhaben inspirierte. Stallman nannte sein Projekt GNU als Abkürzung für »GNU is not UNIX«. Noch wichtiger als die Arbeit an diesem Programm sollte jedoch sein Entwurf der GNU-Lizenz werden. So wollte er von vornherein sicherstellen, dass nicht wieder eine Firma wie AT&T kommen konnte, um Rechte an dem Programmcode anzumelden. Die Idee hinter GNU findet man ausführlich dargelegt unter http:// www.gnu.org/gnu/manifesto.html. Demjenigen, der sich genauer mit der Thematik auseinandersetzen möchte, des Englischen jedoch nicht so mächtig ist, kann ich nur »Die Kathedrale und der Basar«, einen Artikel von Eric S. Raymond in einer Übersetzung von Reinhard Gantar, empfehlen: http://gnuwin.epfl.ch/articles/de/Kathedrale/. Linux, das bekannteste Projekt unter GNU-Lizenz, zählt nun mal eindeutig zu den Betriebssystemen. Es gibt aber auch eine Reihe freier Anwendungsprogramme, über die im Folgenden ein kurzer Überblick gegeben werden soll.

314


7.4.2

Übersicht zur Geschichte der freien Software

Jahr

Ereignis

1963

Einige amerikanische Studenten verstehen sich erstmals als Hacker.

1964

BASIC wird entwickelt. Es wird die erste Sprache der Hobbyentwickler und der ersten Hacker. Zahlreiche Shareware-Programme wurden in BASIC geschrieben.

1969

Arbeit an UNIX und Entwicklung von C. UNIX wird mit eine der Ursachen für die Entwicklung freier Software, und C wird zum wichtigsten Entwicklerwerkzeug. RFC wird von Jonathan B. Postel veröffentlicht. Es ist das Medium zum Austausch von Vorgaben und Infos zur Entwicklung des Internets.

1971

Die E-Mail wird im Netz integriert. Sie wird das Hauptmedium zur Verständigung unter Entwicklergruppen.

1973

Das Ethernet wird von Bob Metcalfe erfunden.

1975

Der PC kommt auf den Markt. Der Editor Emacs wurde in seiner ersten Version von Richard Stallman entwickelt. Er wird hauptsächlich von Entwicklern unter C für das Schreiben von Programmen genutzt. Es ist ein sehr bedeutendes frühes Produkt freier Software.

1977

Donald E. Knuth beginnt das TeX-Projekt, um seine Buchreihe »The Art of Computer Programming« mit höherer Qualität drucken zu können. Er wird 9 Jahre für die Fertigstellung benötigen.

1978

Das moderne Internetprotokoll wird in TCP und IP aufgeteilt.

1979

Erste Multiuser-Spiele werden entwickelt.

1981

TCP/IP wird mittels Geld von der ARPA in BSD-UNIX integriert. Dadurch wird BSD-UNIX zum Netzbetriebssystem.

1983

AT&T verkauft UNIX unter dem Namen UNIX System V als proprietäres System. Die Programmierer/Studenten sehen dies als negative Entwicklung hin zu einer Verteuerung der Software.

1984

Richard Stallman ruft das GNU-Projekt ins Leben, Marco Börries entwickelt StarWriter, das im Jahr 2000 Open Source wird, als Teil eines freien OfficePakets.

1985

Richard Stallman schreibt seinen Editor Emacs neu und macht ihn zum ersten Programm unter seiner neu entworfenen GNU-Lizenz. Man bezeichnet diesen Emacs als GNU-Emacs. 1985 ist auch das Jahr der Gründung der Free Software Foundation (FSF).

1987

Andrew Tanenbaum entwickelt das Betriebssystem MINIX, weil UNIX nicht mehr für Lehrzwecke frei verwendet werden darf (AT&T). Es ist Teil seines Lehrbuchs über Betriebssysteme. In Amerika entwickelt Prof. Douglas Comer Xinu aus dem gleichen Grund.

1988

Die freie Programmiersprache Perl wird von Larry Wall entwickelt.

Tabelle 7.1

Meilensteine der freien Software

315

7.4

7


Jahr

Ereignis

1989

Postgres, ein Datenbanksystem, wird von Michael Stonebraker entwickelt. Es wird 1994 Open Source.

1990

Guido van Rossum entwickelt die freie Sprache Python als Bestandteil des Betriebssystems Ameoba von Tanenbaum.

1991

Linus Torvalds beginnt mit der Entwicklung von Linux, Tim Berners-Lee entwirft das WWW. Bei Sun wird die Sprache Java entwickelt, die zur meistangewandten freien Programmiersprache wird.

1992

Linux wird der GNU-Lizenz unterstellt.

1993

FreeBSD entsteht, und Samba, die freie Netzwerkbrücke zwischen Windows und Linux, wird von Programmieren um Andrew Tridgell entwickelt.

1994

Folgende freie Softwareprodukte werden ins Leben gerufen: 왘 왘 왘

왘

Apache, ein freier Webserver, wird von Robert McCool entwickelt. PHP wird von Rasmus Lerdorf unter der PHP-Lizenz entwickelt. GIMP – Peter Mattis und Spencer Kimball entwickeln das freie Grafikprogramm. MySQL – freier Datenbankserver

1995

CPAN, die freie Perl-Softwaresammlung entsteht; Yukihiro Matsumoto veröffentlicht die Sprache Ruby, die später freie Software wird.

1996

KDE als freie Desktop-Oberfläche wird von Matthias Ettrich unter C++ entwickelt.

1997

Eric S. Raymond schreibt »The Cathedral and the Bazaar« als Plädoyer für freie Software

1998

Netscape gibt den Code des Netscape Browsers frei. Freie Software wird nun unterschieden in Freeware und Open-Source-Software.

1999

Firmen beginnen mehr und mehr, Software für freie Systeme zu entwickeln. Sun übernimmt die Firma StarOffice. Gnome als neue freie DesktopOberfläche für UNIX/Linux-Systeme wird entwickelt.

2000

StarOffice wird unter dem Namen OpenOffice zum freien Office-Paket.

2001

Die Eclipse-IDE wird als Nachfolgerin der Visual-Age-Entwicklungsumgebung von IBM unter CPL als Public Domain freigegeben.

2006

Ab diesem Jahr wird der Code des Java-Compilers freigegeben.

Tabelle 7.1

Meilensteine der freien Software (Forts.)

Falls sich die Cloud-Technik durchsetzen sollte, kann es allerdings sein, dass Software immer seltener auf dem heimischen Rechner installiert werden wird. Software wird dann ohnehin nur noch zeitlich begrenzt zur Nutzung zur Verfügung gestellt werden. Wenn man es genau nimmt, macht Public Domain oder Freeware danach keinen großen Sinn mehr – Software zur Nutzung kostenlos zur Ver-

316

Lesen Sie weiter

fügung zu stellen, dagegen schon. Es wird sich zeigen, ob die Freeware-Szene auf die neue Technik eingeht. »Rechnen, schreiben, lesen tut er – nur nicht denken, mein Computer.« – Klaus Klages (*1938), deutscher Gebrauchsphilosoph und Abreißkalenderverleger

7.5

Lesen Sie weiter


Beschreibung

http://www.sap.com/germany/index.epx

SAP-Homepage

http://www.softwareag.com/de/default.asp Software AG-Homepage http://karl-tux-stadt.de/ktuxs/?p=1902

Linux

http://www-01.ibm.com/software/info/ lotusknows/de

Lotus Notes

http://www.framework.com/

Framework-Office-Programmpaket

http://www.winhistory.de/more/bob.htm

Bob-Webseite

http://www.starmoney.de/

Homepage von StarMoney

http://www.oracle.com/de/index.html

deutsche Oracle-Homepage

http://gnuwin.epfl.ch/articles/de/ Kathedrale/

Artikel »Der Basar und die Kathedrale«

http://www.eclipse.org/downloads/

Eclipse

http://de.openoffice.org/

OpenOffice-Homepage

http://www.gnu.org/gnu/manifesto.html

GNU-Manifest

317

7.5

Bill Gates (Microsoft) und Jim Cannavino (IBM) streiten sich über die Zukunft von Betriebssystemen. Schließlich einigen sie sich darauf, eine Münze zu werfen. Sagt der IBM-Chef: »Liegt die Zahl oben, soll sich OS/2 durchsetzen, bei Kopf wird UNIX der Standard.« »Hey, Sie haben Windows NT vergessen«, wirft Bill Gates ein. »Habe ich nicht«, antwortet Cannavino. »Wenn die Münze hochkant stehen bleibt, gehört die Zukunft Windows NT.« – Anonymus

8

Von CP/M über DOS zu Windows

1963

1969

1981

1991

2000

2004

2009

Multix UNIX DOS Linux Win2000 Ubuntu Windows7

Betriebssysteme sind für heutige Rechner das, was Buchstaben für die Information bedeuten. Sie machen es möglich, dass Informationen aus den Köpfen der Autoren auf der Hardware, dem Papier, gespeichert werden können. Betriebssysteme liegen zwischen der Hardware der Computer und dem Textverarbeitungsprogramm oder dem Computerspiel. Sie machen es überhaupt erst möglich, dass die gleichen Programme auf verschiedenen Rechnern laufen können. Daher sind sie heute noch sehr wichtig – in den Augen so mancher die wichtigste Software überhaupt. Ob das aber die nächsten zehn Jahre noch so bleibt, das ist noch gar nicht sicher.

319

8


8.1

Masterprogramme

Weil wir bei unseren Spielereien mit dem Computer immer wieder auf Betriebssysteme stoßen werden, wollen wir diese jetzt einmal näher betrachten. Bereits bei den Vorbereitungen für die Nutzung der Programmiersprache Java und alle anderen Programme und Beispiele haben wir das eine oder andere Betriebssystem genutzt oder installiert. Was hat es also mit dieser speziellen Art Software auf sich? Wenn man so will, ist das Betriebssystem eine Art Antrieb für einen Computer. Heutzutage sind die Rechner über eine Taschenrechnerfunktionalität hinausgewachsen. Es lassen sich Texte oder gar Bilder bearbeiten. Dafür kamen immer neue Zusatzgeräte (Scanner, Kameras u.a.m.) auf den Markt, die sogenannten Peripheriegeräte. Diese Geräte mussten natürlich auch angesteuert werden. Zusätzlich ergab sich ständig das Problem, genügend Hauptspeicher für laufende Programme zur Verfügung stellen zu müssen. Alles Aufgaben für eine spezielle Software, das Betriebssystem. Den Bezug zur Hardware erkennt man oft bereits am Namen, wie z. B. bei der Abkürzung DOS, die für Disk Operating System steht. Früher unterteilte man in Einbenutzersysteme, Mehrbenutzersysteme, Einzelprogramm- und Multiprogrammsysteme, Batch(Stapel)- und Dialogsysteme. Heute gruppiert man in Betriebssysteme mit textorientierter oder grafischer Oberfläche, in Echtzeit-, Timesharing-, lokale und verteilte Systeme, in Parallelsysteme, PC- und Handheld-Systeme. Eines haben sie alle gemeinsam: Sie sind zum Betrieb der jeweiligen Hardware unabdingbar. Wen wundert es, dass diese offenbar sehr mächtige Art von Software besonders die Medien beeindruckte. So gibt es in dem 1981 gedrehten computeranimierten Hollywood-Streifen Tron aus der Werkstatt des Medienkonzerns Disney einen Superbösewicht mit Namen MCP (= Master Control Program). Dieses Programm beherrscht die Innenwelt des Computers, den Schauplatz des Films, und strebt, wie könnte es anders sein, natürlich die Weltherrschaft an. Zum ersten Mal wurde eine große Öffentlichkeit mit Begriffen wie I/O für Input-Output, mit Computeranimationen und Computerspielen konfrontiert. Das Computerzeitalter begann seinen Einzug in die Privathaushalte, und das böse Programm MCP ist nichts anderes als die filmische Umsetzung eines Betriebssystems. An welches konkrete Betriebssystem mögen die Schöpfer von Tron dabei wohl gedacht haben?

320

Masterprogramme

8.1.1

Geschichtlicher Überblick

Die allerersten Rechner benötigten keine Betriebssysteme. Entweder arbeiteten sie mechanisch und besaßen überhaupt keine Software, oder es handelte sich um Einzelstücke, wie die ersten elektronischen Rechner ENIAC oder Mark I. Erst als Rechner in Serie produziert wurden und Baureihen aufkamen, wurde es wichtig, Softwareschnittstellen zu schaffen, auf denen Anwendungsprogramme ablaufen konnten, ohne an jeden Rechner separat angepasst werden zu müssen. Das erste Betriebssystem, das auf diese Weise über mehrere Modellreihen eingesetzt wurde, war OS/360, das IBM 1964 mit der Modellreihe System/360 einführte. Wahrscheinlich ist es auch das Betriebssystem, das am längsten in unveränderter Form genutzt wurde. UNIX ist zwar schon länger in Gebrauch, wurde jedoch ständig verbessert. Für die neuen Mini- und Mikrocomputer mussten andere Betriebssysteme entwickelt werden. In der Programmiersprache PL/1 wurde ab 1963 beispielsweise das System Multics entwickelt. Verfügbar war es ab 1969. Angeregt von den Arbeiten an Multics, entwickelten Ken Thompson und Dennis Ritchie an den Bell Laboratories von AT&T 1969 das Betriebssystem UNIX. Es fand weltweite Verbreitung und wurde insbesondere an den amerikanischen Universitäten weiterentwickelt. Vor wenigen Jahren wurde nach ihm das neue, aber an die Funktionsweise angelehnte, freie Betriebssystem Linux benannt. Etwa zur gleichen Zeit wie UNIX wurde von Gary Kildall das System CP/M entwickelt, und kurz darauf erblickte PC-DOS das Licht der Welt. Was wir heute noch als DOS bezeichnen, ist eigentlich eine Entwicklung von Microsoft und einer der Gründe für den Erfolg dieses Unternehmens. Es wurde am 12. August 1981 in der Version 1.0 mit dem IBM-PC auf den Markt gebracht. Computer für den normalen Geldbeutel gab es damals schon eine ganze Zeit, aber IBM brachte mit seinem PC ein Gerät, in dem es Steckplätze gab, für die jede Firma, die Lust dazu hatte, Steckkarten bauen konnte. Genau diese Möglichkeit, spezielle Teile wie Grafikkarten zuzuliefern, war am Ende ausschlaggebend für den großen Erfolg des IBM-PCs und seiner Nachbauten, der sogenannten PCClone.

8.1.2

Wie war das eigentlich mit DOS?

Die Urheberrechte an älteren Betriebssystemen sind nicht einfach so freigegeben, daher hat man sie in der Freeware-Gemeinde nachprogrammiert und der Öffentlichkeit zur Verfügung gestellt. Eine sehr bekannte Version eines nachprogrammieren DOS ist FreeDOS. Falls Sie es noch nicht kennen, sollten Sie es sich

321

8.1

8


einmal ansehen. Man findet es im Internet unter http://www.freedos.org/freedos/ files/. Auch auf der Buch-DVD ist eine – allerdings etwas ältere – Version verfügbar1, und zwar unter Software zum Buch\Kap08\FreeDOS\fdfullcd.iso. Es handelt sich um eine ISO-Datei, die auf eine CD gebrannt werden kann und für die Installation auf einem virtuellen Rechner zur Verfügung steht. Sie kann aber auch direkt genutzt werden: übers Menü mit Hilfe von Datei 폷 Manager für virtuelle Medien... 폷 CD/DVD-Abbilder 폷 Hinzufügen. Schließlich muss unter Massenspeicher CD bei den Attributen in der Zeile CD/ DVD-Laufwerk das eingerichtete Medium ausgewählt werden. Außerdem muss die Boot-Reihenfolge bei Ändern 폷 System an erster Stelle das DVD-Laufwerk stehen haben. Nach dem Start wird ein Begrüßungsdisplay gezeigt, wobei mit einer 1 (¢) der Bootvorgang von der CD aktiviert wird. Die Standardinstallation 1. wird ausgewählt und mit Return bestätigt. Dann lässt sich als Sprache Deutsch wählen und die Installation mit dem ersten Menüpunkt fortsetzen. Das muss dreimal bestätigt werden, bis man zur Verzeichnisauswahl kommt. Auf einem virtuellen Rechner kann man alles so belassen, wie es ist. Letztendlich folgt eine ganze Reihe von Abfragen zu einzelnen Dateien der Installation. Das können Sie im Grunde unverändert lassen und jeweils mit (¢) bestätigen. Am Ende erfolgt eine Abfrage nach dem Driver für das Netzwerk. Sollten Sie die Driver-Installation nicht hinbekommen, können Sie auch ohne Netzwerk-Driver installieren, das tut der Nutzung keinen Abbruch. Die GEM-Installation sollte man aber in jedem Fall durchführen. GEM ist eine frühe grafische Oberfläche, ein lebendes Fossil, das man sich unter FreeDOS originalgetreu ansehen kann. Mit DOS arbeiten DOS oder Disketten Operating System war von Anfang an das Betriebssystem des IBM-PCs und wurde damit zum weit verbreitetsten System, zum Fahrstuhl für den Aufstieg der Firma Microsoft. Grundlage des Systems sind die Befehle für die Verwaltung und den Aufruf von Dateien, die auf fixen Datenträgern wie Disketten oder Festplatten und CDs gespeichert sind. Da es nur einen Hauptprozess gab, also kein Multitasking, brauchte das auch nicht gesteuert zu werden.

1 Da sich die neueste Version auf Virtual Box nicht installieren lässt.

322

Masterprogramme

Die wichtigsten Befehle in DOS sind: Befehl

Erläuterung

dir

Zeigt den Inhalt des aktuellen Verzeichnisses an.

cd

Wechselt zum angegebenen Verzeichnis (kann für das Parentverzeichnis und \ für Root genutzt werden).

mkdir

Legt das angegebene Verzeichnis an.

rmdir

Löscht das angegebene Verzeichnis.

del

Löscht die genannte Datei.

help

Liefert Hinweise zu den Befehlen.

rename

Benennt Dateien um.

edit

Startet den Editor.

date

Zeigt das Datum an.

time

Zeigt die Uhrzeit an und ändern sie.

Tabelle 8.1

DOS-Befehle

Die DOS-Befehle sind durchaus nicht überholt, DOS dient unter Windows noch immer als Konsole. Kennt man sich also in DOS aus, lassen sich viele Routinearbeiten am Betriebssystem auf der DOS-Konsole rascher erledigen, als dies unter der grafischen Oberfläche von Windows möglich ist. Ein einfacher Vergleich soll aufzeigen, was gemeint ist: Man kopiert ein Verzeichnis von der beiliegenden DVD in das Verzeichnis temp der Festplatte C: Das Verzeichnis Software zum Buch eignet sich ganz gut dazu, es enthält viele Unterverzeichnisse und große Mengen an Dateien. Zuerst löscht man es mit dem Datei-Explorer von Windows. Je nach Rechner dauert das bis zu zehn Minuten und länger. Nun kopiert man das Verzeichnis erneut nach temp und löscht es wieder von der DOS-Konsole aus von der Platte: Start-Menü anklicken und cmd im Suchen-Feld eingeben. cd /temp del /S/Q "Software zum Buch"

Wobei del die Kurzform für delete (löschen) ist. Noch besser wäre remove directory (entferne Verzeichnis): rmdir /S/Q "Software zum Buch"

323

8.1

8


Der Geschwindigkeitsunterschied ist gravierend. Je nach Rechnerleistung dauert es jetzt nur Bruchteile von Sekunden, um alles zu löschen, und das hauptsächlich, weil keine zeitaufwendige grafische Darstellung des Vorgangs erforderlich ist. Durchaus ein Argument, um öfter mal in der DOS-Konsole zu arbeiten. Viel war DOS also eigentlich nicht – es handelte sich um einen Befehlsinterpreter mit einer Textoberfläche und ein paar Hilfsprogrammen. Zwar war es ein einfaches Betriebssystem, aber längst kein Batch-Betriebssystem mehr wie die ersten Betriebssysteme. Was bedeutete, dass man Auftragslisten erstellte, die wie an einem Fließband abgearbeitet wurden. Es gab auch keine Interaktion, weil die Arbeit der Rechner nur darin bestand, eingefütterte Aufträge durchzuführen. DOS dagegen wartete bereits auf die Eingaben eines Nutzers und war damit interaktiv. Doch Nutzerfreundlichkeit lässt sich steigern, wie sich bald zeigen sollte.

8.2

Die Windows-Story

Das heute meistgenutzte Betriebssystem hat eine eigene, fast eigenwillige Geschichte. Witzigerweise ist der Beginn eng mit der des Apple-Betriebssystems verknüpft. Im sogenannten Silicon Valley (Palo Alto) wurde im Xerox-Forschungsinstitut Xerox Palo Alto Research Center (PARC) an den neuesten Rechnerkonzepten gearbeitet. Es gab keinen Zeitdruck und keine Richtlinien, so dass neue Ideen ungehemmt keimen konnten. In der Tat hatte man revolutionäre Ideen realisiert, unter anderem die grafische Oberfläche mit der Maus als steuernde Hardware und eine neue Programmiersprache auf Basis des objektorientierten Paradigmas. Das Institut und Xerox waren weniger an der Vermarktung der einzelnen Ideen als an einem Gesamtprodukt mit ihren neuen Rechnern, Alto und Star, interessiert. Man versteckte sich jedoch nicht, sondern zeigte die Ergebnisse der Forschungstätigkeit recht freizügig. Besucher waren unter anderem Bill Gates, aber auch Steve Jobs, der auf Betreiben eines gewissen Dominik Hagen einmal vorbeikam. Die Szene wurde inzwischen für YouTube nachgestellt und kann dort bestaunt werden: http://de.sevenload.com/videos/n593w7S-Apple-und-Xerox). Steve Jobs bot Xerox an, die Technologie zu kaufen. Wie bereits erwähnt, bestand daran jedoch kein Interesse. Als Steve Jobs Xerox jedoch Aktienanteile von Apple überließ, wurde ihm erlaubt, ausgewählte Apple-Entwickler mitzubringen, die sich alles noch einmal anschauten.

324

Die Windows-Story

© Xerox

Wen wundert es, dass die Leute von Xerox heute noch nicht gut auf die Vorgänge von damals zu sprechen sind. Ein kurzer trockener Text in ihrer History-Webseite weist darauf hin: http://www.parc.com/about/history/.

Abbildung 8.1 1975 erblickte in den Xerox Parcplace Labors die grafische Oberfläche das Licht der Welt. Hier ein Werbeplakat für den Xerox 8010/40.

Jetzt stand bei Apple fest: Der grafischen Benutzeroberfläche gehört die Zukunft. Die neue Technik durfte man nicht kaufen, so entwickelte man einfach etwas Eigenes, in der Art, wie man es bei Xerox gesehen hatte. Das Gleiche machten die Entwickler um Bill Gates.

325

8.2

8


8.2.1

Das »Ur-Windows«

Was Jobs und Gates damals in Silicon Valley zu sehen bekamen, kann man heute nicht mehr ganz genau rekonstruieren. Trotzdem können wir es recht gut auf unseren Computern nachempfinden. Was am Ende aus dem Xerox-Labor ans Licht der Öffentlichkeit trat, war nämlich Smalltalk 80. Und das war 1980, wie der Name assoziiert. Damals wurde dieses Smalltalk standardisiert. Ursprünglich entwickelt wurde es bereits 1972 am Palo Alto Research Center von Xerox, als Teil des sogenannten Dynabook, eben des Konzeptes, das die beiden ComputerAsse damals auf dem aktuellen Entwicklungsstand zu sehen bekamen. Auch wenn heute oft behauptet wird, Smalltalk sei ursprünglich als Entwicklungswerkzeug für Kinder gedacht gewesen, so sagt das doch nichts über die Qualität der dabei entstandenen Ideen aus. Außerdem ist es nicht wahr. Bei Xerox war man bestrebt, einen Bürocomputer zu bauen, der einfacher zu bedienen sein sollte. Der Xerox 8010 hatte eine grafische Oberfläche, die Programmiersprache Smalltalk und eine Maus. Aber er hatte auch zwei Nachteile: Die Objektorientierung war so revolutionierend, dass sie kaum jemand nachvollziehen konnte, und der Rechner war mit 16.595 $ für Privatleute kaum erschwinglich (http://www.mark13.org/node/63). Trotzdem war er mit Sicherheit einer der ganz großen Geniestreiche in der Geschichte der EDV. Unterstrichen wird dies schon dadurch, dass der Entwickler Alan Kay dafür 2003 den Turing Award erhielt, den »Nobelpreis der EDV«. Das erste Smalltalk ist heute noch verfügbar, wenn auch die Rechte nicht ganz geklärt sind. Hier und da lässt es sich im Internet aufstöbern, und wer Lust hat, kann danach suchen und es sich auf einem virtuellen DOS-PC installieren (siehe Abbildung 8.2). Was man zu sehen bekommt, ist sozusagen das Ur-Windows, die erste grafische Oberfläche überhaupt. Sie ist eine Nachbildung der Schreibtischarbeit mit ihren Papierbögen und Zetteln. Die Fenster sind einfach gestaltet, simple Linien als Rahmen und ein Kopf ohne System-Icons. Die Bedienung ist rein mausorientiert, die Maus war gleichzeitig für diese Oberfläche erfunden worden. Durch Klicken mit der rechten Maustaste auf die Kopfleiste wurde ein Menü geöffnet, in dem man untenliegende Fenster hervorholen, die Größe des Fensters ändern oder es verschieben konnte. In Kapitel 6, »Von Lady Ada bis F#«, erfahren Sie mehr über Smalltalk.

326

Die Windows-Story

Abbildung 8.2

Die Oberfläche von Smalltalk 80

GEM MS-Windows selbst wurde gar nicht als eigenes Betriebssystem entwickelt, sondern lediglich als Aufsatz für DOS, als grafische Oberfläche, die wie ein Anwendungsprogramm unter DOS gestartet werden konnte. Die Version 1.0 ist übrigens nicht in den Handel gekommen. Das erfolgreichste Windows jener Zeit wurde Version 3.1. Witzigerweise hatte Gary Kildall sein GEM als grafische Oberfläche für CP/M noch eher fertig als Microsoft sein Windows für DOS (siehe Abbildung 8.3). GEM ist als FreeGEM auch mit auf der DVD enthalten. Wenn Sie FreeDOS vollständig installiert haben, wurde auch GEM mitinstalliert, und Sie können es sich nun anschauen. Fahren Sie den DOS-Rechner unter VirtualBox hoch, und geben Sie auf C: einfach GEM (¢) ein, um die grafische Oberfläche zu starten.

Wie man schnell feststellt, ist eine grafische Oberfläche vor allen Dingen mit der Symbolisierung und Visualisierung der Datenbestände eines Rechners verbunden. Die Bedienung ist im Grunde nicht viel anders als beim heutigen Windows. Die Fenster kann man mit dem rechten System-Icon minimieren oder maximie-

327

8.2

8


ren und mit dem linken schließen. Man kann mit diesem Icon auch ein Unterverzeichnis wieder verlassen. Mit dem Doppelklick gelangt man in Unterverzeichnisse, kann aber auch Programme starten. Nach dem Verlassen der Programme kommt man wieder zu GEM zurück. An Tools und Programmen hat es nicht viel zu bieten – im Grunde nämlich nur einen Taschenrechner und eine Uhr. Ein Papierkorb war bereits vorhanden, der das Löschen von Dateien und Verzeichnissen visuell verständlich machte.

Abbildung 8.3

8.2.2

Eine der ersten grafischen Oberflächen war GEM.

NT – New Technology

Nach diesem Abstecher wir den weiteren Werdegang von Windows verfolgen, der als Grafikzusatz zu DOS begann. Nun galt es, die grafische Oberfläche weiter zu verbessern, aber auch ein modernes Betriebssystem zu bauen, das mehrplatz- und serverfähig sein sollte. In DOS konnte zu einem Zeitpunkt immer nur eine Anwendung genutzt werden, und personalisierte Nutzung durch mehrere Personen war auch nicht möglich. So fing Microsoft in den frühen 90er Jahren damit an, ein ganz neues Betriebssystem zu entwerfen. Erfahrungen wurden bereits gesammelt, als zwischen 1987 und 1991 für IBM das sogenannte OS/2 entwickelt wurde. Es besaß entfernte Ähnlichkeiten mit Windows, hatte jedoch einen eigenen Betriebssystemkern, der nicht wie bei DOS/Windows von der grafischen Oberfläche getrennt war.

328

Die Windows-Story

Das neue Windows sollte Serverfähigkeit mitbringen, so war es nicht für den Heimanwender geplant, sondern ausschließlich für den Büroeinsatz. Es kam als Windows NT 3.1 im Juli 1993 auf den Markt, was nicht nur den Schritt zu einer neuen Technologie kennzeichnete, sondern auch die herausragende Stellung von Windows 3.1 noch einmal unterstrich. NT stand in diesem Falle wirklich für einen Neuanfang. Es war nicht mehr mit DOS unterlegt, sondern hatte eine eigene Abstraktionsebene oberhalb der Hardwarezugriffe, den HAL (Hardware Abstraction Layer). Somit gab es für die Programme keinen direkten Hardwarezugriff mehr, und für Spiele, die den schnellen direkten Zugriff brauchten, musste ein Zusatz her, genannt DirectX. Ohne DirectX waren nur sehr langsame Grafikzugriffe möglich, und damit konnten Spiele nicht flüssig laufen. DirectX, wie ein Tunnel angelegt, der direkt vom Spiel zur Hardware führt, machte die Spiele wie unter DOS schnell und damit spielbar. NT war allerdings für den Büromarkt gedacht. Für den Heimanwender benötigte man ebenfalls wieder mal ein Betriebssystem-Update. Windows 95 war »pünktlich« im August 1995 in den Läden zu kaufen. Zuvor wurde es als Windows 4.0 oder unter dem Codenamen »Chicago« geführt. Das Neue an dem System waren nicht nur Änderungen an der Oberfläche, sondern vor allem der Umstieg von 16- auf 32-Bit-Prozessortechnologie. Nach wie vor lief es allerdings auf DOS und war damit, wie seine Vorgänger, eine separate grafische Oberfläche für DOS. Das Programm wurde auf Disketten sowie auf CD-ROM plus Startdiskette ausgeliefert. Von CD-ROM konnte nicht gebootet werden. Das System war ein großer Verkaufserfolg, obwohl nur eine Version ausgeliefert wurde. Mehrere Folgeversionen wurden nur als OEM-Versionen in Verbindung mit Rechnern geliefert.

8.2.3

Das Millennium-Gespenst geht um

Windows NT wurde in verschiedenen Versionen ausgeliefert, von 3.1 bis 4.0. Die schöne, neue, noch buntere Betriebssystem-Welt war wieder in Ordnung. Obwohl sich ein gewisser Linus Torvalds bereits darangemacht hatte, Linux zu entwickeln. Doch das interessierte nur eine Handvoll Enthusiasten. Etwas weit Gewaltigeres zeichnete sich am Horizont der Zeitrechnung ab: richtig, das neue Jahrtausend. Man sprach auch vom y2k-Problem und vom sogenannten Millennium-Bug. Dabei war es weder ein Fehler noch eigentlich ein Problem. Es war einfach nur Nachlässigkeit der Programmierer, die seit den 50er Jahren ihre Programme schrieben und wohl nie darüber nachdachten, dass sie Teil einer Technik waren, die wohl Hunderte von Jahren ihre Arbeit tun muss. In allen Programmen

329

8.2

8


und auch in den meisten Betriebssystemen gab man Jahreszahlen immer nur mit zwei Stellen an. Das sparte in dem Moment Speicherplatz, wenn man das Datum als String darstellen musste. Der Nutzen war kaum der Rede wert, aber es wurde halt gemacht. Nun war guter Rat teuer. Viele zogen in Betracht, die Angelegenheit einfach auf sich beruhen zu lassen. Der Nutzer sollte bedenken, dass statt 1901 das Jahr 2001 war, falls der Rechner eine solche Zahl anzeigte. Aber ganz so einfach war das nicht. Man konnte sich nicht recht vorstellen, wie ein Rentner seine Rente bekommen sollte, wenn der Computer plötzlich der Meinung war, der Mann sei noch gar nicht geboren. Bei Windows-PCs glaubte man sogar, es sei möglich, dass der Kalender statt auf 1900 auf 1980 oder 1984 springen könnte. Offenbar hatten hier die Entwickler den Beginn der Zeitrechung mit dem Beginn der Entwicklungsarbeit an DOS gleichgesetzt. Hektische Betriebsamkeit entwickelte sich, wo jahrzehntelang sträfliche Unbefangenheit herrschte. Man begann die abenteuerlichsten Projekte ins Leben zu rufen, die nicht selten über nicht weniger abenteuerliche Etats verfügten. Von Krankenhäusern bis zu Militärs war alles damit beschäftigt zu experimentieren. Was passiert, wenn man an einem UNIX-Rechner die Uhr von 1997 auf 2001 stellt? Nichts, aber wenn man sie wieder zurückstellt! Der Rechner hat nämlich plötzlich Dateien auf der Festplatte, die in das Jahr 2001 datieren, die es 1997 also gar nicht geben darf. Das Betriebssystem hängt sich auf. Diese und ähnliche Erkenntnisse machten sich breit und kosteten Unsummen. Aber das war gar nichts gegen die Katastrophen, die man kommen sah. Am 31.12.1999, Punkt Mitternacht, sollten Flugzeuge vom Himmel stürzen, Kernkraftwerke ausfallen, Fahrstühle stecken bleiben, Atomraketen scharf gemacht werden, Telefone klingeln, Fabrikanlagen ausfallen, Krankenhäuser evakuiert werden und Rechner, die versehentlich nicht abgeschaltet wurden, ihre Festplatten löschen. Vielleicht sollte man wirklich jede EDV-Anlage der Welt für eine Minute herunterfahren. Am 1.1.2000 könnte man sie wieder in Betrieb nehmen. Die Frage war nur, würde es helfen? Oder hatte man den Supergau damit nur um eine Minute verzögert? Die Angst ging um, und mit Angst ließ sich schon immer gut Geld verdienen. Neue Verfahren wurden erdacht, Programme hastig niedergeschrieben, Urkunden ausgestellt und Plaketten aufgeklebt (siehe Abbildung 8.4). Einrichtungen wie die NSTL, National Software Testing Laboratories, in Amerika, brauchten ihre Existenzberechtigung nicht mehr mit langen Erläuterungen zu belegen. Jeder wollte sich plötzlich ihrer Dienste versichern.

330

Die Windows-Story

Abbildung 8.4

Diese Hardware ist Jahr-2000-tauglich, Plakette der NSTL.

Auch Microsoft gehörte zu den Kunden. Es hatte sich rechtzeitig, nämlich am 27. September 1997, mit der ersten Betaversion von Windows NT 5.0 in der Lage gezeigt, das Problem zu meistern und die Welt endgültig zu retten. Demzufolge entschloss man sich im Oktober 1998, das neue Windows auf Windows 2000 umzutaufen. Der Jahrtausendwende stand also nichts mehr im Wege. Angesichts der Größe des Problems wurde Windows 2000 jedoch erst am 17. Februar 2000 veröffentlicht. Wie Windows 2000 sind auch die noch folgenden Versionen, Windows XP, Windows Server 2003 und Windows Vista, eine Weiterentwicklung auf Basis von Windows NT 3.1. Das Jahr-2038-Problem Die Erfahrung mit dem Millennium-Bug machte die Entwickler natürlich hellhörig, und sie durchforsteten die bestehende Software nach weiteren Gefahren in dieser Größenordnung. Es dauerte nicht lange, bis sie fündig wurden mit dem Jahr-2038Problem. Alle Betriebssysteme, die den POSIX-Kalender nutzen, wie Linux, haben das Problem eines sogenannten Überlaufs am 19. Januar 2038, um 03:14:08 Uhr, weil sie die Zeit in Sekunden seit dem 1. Januar 1970 zählen und dafür 32-Bit-Integer nutzen. Vorzeichenbehaftete Zahlen unterscheiden mit dem letzten Bit, das ganz links steht, ob die Zahl positiv oder negativ ist. Gelangt der Zähler bei 2147483647 an und zählt noch 1 hinzu, wird die Zahl negativ, und durch die Umrechung wird der Rechner nicht mehr den 19. Januar 2038 anzeigen, sondern den 13. Dezember 1901, 20:45:52 Uhr. Allerdings ist zu erwarten, dass wir bis zu diesem Zeitpunkt längst Rechner mit 256 Bit breitem Bus und entsprechend leistungsfähigerer Software haben. Auch die Errechnung des aktuellen Datums dürfte auf andere Weise erfolgen. Beispielsweise mit einer 64-Bit-Integerzahl. Womit also die 2038-Katastrophe wahrscheinlich vermieden wird.

331

8.2

8


»Wenn Computer wirklich so großartig sind, warum brauchen sie dann bereits direkt nach dem Einschalten ein Betriebssystem?« – Anonymus

8.3

Linux/Ubuntu

UNIX, das große professionelle Betriebssystem für Netzwerke und Hochleistungsrechner gibt es schon lange. Es hat sich parallel zu den Systemen für Mikrocomputer entwickelt und lief in erster Linie auf Minicomputern und größeren Anlagen. Beides, Soft- wie Hardware, war so teuer, dass es für den Privatanwender kaum infrage kam und auch nie wirklich in großen Stückzahlen ausgeliefert wurde.

8.3.1

Linux tritt auf den Plan

Während sich Windows fortentwickelte, hatte still und heimlich ein weiterer Akteur die Bühne betreten: Linux. Als UNIX-ähnliches System hatte es von vornherein einen ganz anderen Aufbau als die Betriebssysteme der DOS-Schiene. Es war vor allen Dingen multitasking- und multiuserfähig. Was besagt, dass der Rechner seine Leistung so verteilt, dass auch mehrere Anwender an einer Aufgabe arbeiten können – jeder mit einem eigenen geschützten Plattenplatz. Die Auswirkungen von Linux waren immens und sind noch lange nicht am Ende angelangt. Sie sind jedenfalls weit größer, als es der Entwickler des sogenannten Kernels, Linus Torvalds, abschätzen konnte, als er 1991 mit der Programmierung anfing. Nicht nur, dass es heute fast für jede Hardware verfügbar ist, vom Videorekorder bis zum Supercomputer, es wurde als Open-Source-Projekt ins Leben gerufen und hat die Softwareszene damit maßgeblich verändert. Das Wichtige an Betriebssystemen wie UNIX und Linux ist die Virtualisierung der Betriebsmittel, also der Hardwarekomponenten. So wird auf alle Geräte über Dateien zugegriffen. Laufwerke werden so abstrahiert, dass sie nur noch Teil des Verzeichnisbaums sind und nicht als Laufwerke angesprochen werden. Der Arbeitsspeicher ist nicht an den Hauptspeicher gebunden, sondern wird als virtueller Speicher durch den Plattenplatz ergänzt, was in Windows inzwischen natürlich auch so gemacht wird. Die Virtualisierung reicht bis zum Prozessor. Hier hat die Sache allerdings ihre Grenzen, obwohl Xen, das für die Virtualisierung ganzer Rechner steht, inzwischen mit den meisten Linux-Distributionen ausgeliefert wird.

332

Linux/Ubuntu

8.3.2

Shuttleworths Geschenk an die Menschheit

Wenn wir schon dabei sind, nutzen wir die virtuelle Technik gleich einmal, um Ubuntu, eine der vielen Linux-Distributionen, auf unserem virtuellen Rechner laufen zu sehen (zur Installation siehe Anhang A). Es ist eine Distribution, die vom südafrikanischen Millionär und Computerfreak Mark Shuttleworth stammt. Man erzählt sich die Anekdote, er habe auf seinem Weltraumflug gesehen, dass die Erde gar nicht so groß sei, wie er ursprünglich dachte, und es demzufolge gar nicht so unmöglich sein könne, Microsoft zu besiegen. Mit pfiffigen Ideen hat er kurz nach seinem Studium einige Firmen gegründet und war zu viel Geld gekommen. Er träumte schon als kleiner Junge davon, einmal ins All zu fliegen, so ergriff er die Chance, sobald die Russen Flüge zur ISS für Privatleute anboten, und verkündete am 5. Januar 2002: »Ich will der nächste Weltraumtourist werden.« So wurde er für 20 Mio. $ zum zweiten Weltraumtouristen und zum ersten Afrikaner im Weltall. Zurück auf der Erde verwirklichte er seinen nächsten Traum, Afrika ein eigenes, kostenloses Betriebssystem zu schenken. Es musste eine Linux-Distribution sein, und damit sie sich auf dem hart umkämpften Markt auch durchsetzte, ließ er für mehrere Millionen Dollar CD-ROMs pressen. Jeder, der das System über die Homepage bestellte, erhielt kostenlos so viele Exemplare, wie er wollte.

Abbildung 8.5

Ubuntu als Geschenkpackung von Herrn Shuttleworth

333

8.3

8


Das mag zwar wie ein Scherz oder Märchen klingen, ist jedoch wahr und eine kleine Episode aus dem Kampf um Marktanteile und Absatzzahlen. Ubuntu ist ein etwas reduziertes Linux, das nutzerfreundlicher aufgebaut ist als üblicherweise eine der vielen anderen Linux-Distributionen. Wie fast alle LinuxDistributionen kann sie kostenlos aus dem Internet bezogen werden. Die Webseite von Ubuntu ist http://www.ubuntu.com/. Die ISO-Datei, die man sich von der Webseite ziehen kann, brennt man auf einen CD-Rohling. Mit diesem Rohling kann man Ubuntu auf einer virtuellen Maschine installieren. Es handelt sich um ein Live-System, daher kann man es auch verwenden, um sich Ubuntu anzusehen, ohne es installieren zu müssen. Der größte Vorteil allerdings ist die ausgezeichnete Nutzerunterstützung, die in Deutschland durch ubuntuusers.de gewährleistet wird.

Abbildung 8.6

Ubuntu bietet eine ausgezeichnete Nutzerunterstützung.

Ubuntu kommt – wie alle Linux-Versionen – mit einer ganzen Reihe von Anwendungen, die zudem über das Internet ergänzt werden können.

334

Linux/Ubuntu

Dazu geht man über das Menü: Anwendungen 폷 Software-Center. In einem Dialogfenster werden zunächst einmal die Softwaregruppen angezeigt. Bei Ubuntu muss man berücksichtigen, dass zwischen für Ubuntu freigegeben, geprüfter Software und ungeprüfter Software unterschieden wird. Sieht man sich die zur Verfügung stehende Software an, liest man in diesem Zusammenhang oft: »Diese Software wird von Canonical nicht unterstützt.« Dieser geheimnisvolle Name ist relativ einfach zu verstehen. Canonical Ltd. ist eine Firma, die ihren Sitz auf der Isle of Man hat, einer winzigen Insel zwischen England und Irland. Das Unternehmen wurde von Mark Shuttleworth gegründet, um Ubuntu zu pflegen und zu vermarkten. Inzwischen gibt es Niederlassungen in London und Montreal. Auf Software, die von Canonical für Ubuntu freigegeben wurde, kann man sich also verlassen, was die Stabilität angeht. Einige der wichtigsten Anwenderprogramme unter Ubuntu sind: 왘

OpenOffice.org OpenOffice ist ein Office-Paket mit Textverarbeitung, Tabellenkalkulation, Datenbank, Formel-, Grafik- und Präsentationsprogramm, das ursprünglich von StarOffice-Gründer Marco Börries entwickelt worden war. Es wurde erst von Sun übernommen und ging bei der Sun-Übernahme durch Oracle an diese Firma. Es ist ein sehr gut durchdachtes Office-Paket, das durchaus mit MS-Office mithalten kann und von der Bedienung her an Office 2000 erinnert.

왘

GIMP GIMP ging aus einer Studentenarbeit von Peter Mattis und Spencer Kimball ab 1995 hervor. Der Name ist eine Abkürzung für Gnu Image Manipulation Programm.

Die weitaus meisten Programme unter Linux wurden auch auf Linux entwickelt. Es gibt sogar einige Programme, die später für Windows fit gemacht wurden. Bei einem Programm trifft das besonders zu: GIMP. Dieses Grafikprogramm war unter Linux so erfolgreich, dass es nun auch für Windows und andere Betriebssysteme erhältlich ist. Das Schöne daran ist natürlich, dass es kostenlos ist und unter Ubuntu auch direkt übers Internet installiert werden kann. Es gehört außerdem zur Standardausstattung einer Ubuntu-Distribution. Das können Sie überprüfen, wenn Sie die Menüpunkte Anwendungen 폷 Grafik aufrufen (siehe Abbildung 8.8). Sollte das Programm fehlen oder es sich um eine alte Version handeln, kann es einfach übers Internet upgedatet werden. Entscheidend dafür ist allerdings, dass über den virtuellen Rechner auf die Internetverbindung des realen Rechners

335

8.3

8


zugegriffen wird, um ins Internet gelangen zu können. Das geht in VirtualBox ganz einfach über den Menüpunkt Geräte 폷 Netzwerkadapter (siehe Abbildung 8.7). NAT steht für Network Address Translation. In dem kleinen virtuellen Netzwerk zwischen dem Netzadapter im Wirts-Rechner und dem virtuellen Adapter im simulierten System dient es dazu, die Internetverbindung »durchzuschleifen«.

Abbildung 8.7

Netzwerkadapter auswählen

In Ubuntu selbst gibt es in der Systemleiste oben rechts ein einfaches Icon für das Netzwerk (siehe Abbildung 8.7). Falls die Verbindung nicht aufgebaut werden kann, besteht hier auch die Möglichkeit der manuellen Konfiguration. Diese Netzwerkverbindung wird nur innerhalb eines Rechners von Windows zu Ubuntu abgewickelt. Nachdem Sie mit dem Browser überprüft haben, ob die Internetverbindung aufgebaut wird, können Sie das Betriebssystem um ein zusätzliches Programm bereichern. Hierzu rufen Sie folgenden Menüpunkt auf: System 폷 Systemverwaltung 폷 Synaptic-Paketverwaltung. Wählen Sie den Menüpunkt Bearbeiten 폷 Suchen, und geben Sie Gimp ein. GIMP wird daraufhin in der Liste markiert, und das Kontrollkästchen vor dem Namen

336

Linux/Ubuntu

kann aktiviert werden. Danach gilt es nur noch auf das Icon Anwenden zu klicken. Nach einer einmaligen Bestätigung beginnt auch schon die Installation. Spätestens jetzt sollte GIMP Teil des Menüs sein (siehe Abbildung 8.8).

Abbildung 8.8

GIMP ist installiert.

Nach dem Start des Programms öffnen sich zahlreiche Dialogfenster. Als kleines Beispiel für die Leistungsfähigkeit von Ubuntu und GIMP lassen wir rasch einen Schriftzug erstellen. Wählen Sie im Menü des Dialogs mit der Aufschrift GNU Image Manipulation Program die Menüpunkte Filter 폷 Skript-Fu 폷 Scripte auffrischen. Ansonst stehen die Filter, die wir nutzen möchten, unter Filter 폷 Alpha als Logo nicht zur Verfügung. In einem nächsten Schritt legen wir eine Abbildung an: Datei 폷 Neu. Die Bildgröße sollte wenigstens 640 × 400 Pixel sein. Aus dem Werkzeugkasten wählen wir das große A-Symbol, das für die Texteingabe steht. Nach dem Anklicken der Zeichenfläche öffnet sich ein Dialog, der ein Textfeld enthält. Hier tragen Sie beispielsweise More Coding for Fun ein. Nach 337

8.3

8


dem Schließen des Textdialoges wählen Sie die gewünschte Funktion aus, und zwar über Filter 폷 Alpha als Logo 폷 Frostig... Jetzt müssen wir noch einmal mit OK bestätigen, um folgendes Ergebnis zu erhalten:

Abbildung 8.9

Der Schriftzug aus GIMP

Dieses kleine Beispiel hat gezeigt, dass es sich bei Linux wie Ubuntu nicht um ein zurückgebliebenes Betriebssystem, sondern um ein modernes System mit interessanten Programmen handelt.

8.3.3

Der Mikrokernel

Als Linus Torvalds bekannt gab, dass er einen Kernel für ein neues UNIXBetriebssystem entwickelt hat, bekam er Ärger mit einem der großen Softwaretheoretiker, nämlich mit Andrew S. Tanenbaum. Dieser war der Meinung, dass ein monolithischer Kernel nicht mehr zeitgemäß sei. Man nennt den Kernel deshalb monolithisch, weil er aus einem zusammenhängenden Programm besteht. Tanenbaum spricht vom Mikrokernel als einem kleinen Kernprogramm, das sich die angeforderten Funktionen jeweils zulädt. An sich hat Prof. Tanenbaum natürlich Recht, aber Mikrokernel machen ein Betriebssystem langsamer als ein monolithisches System, und als Linux entwickelt wurde, war der PC noch nicht so schnell wie heute. Auch sind echte verteilte Systeme mit Mikrokernel einfacher zu realisieren. Natürlich gibt es inzwischen längst mit Linux verwandte Mikrokernel-Systeme. Eines davon sollte man vielleicht einmal unter die Lupe nehmen. Es heißt QNX und ist ein Echtzeitsystem. Also ein System, das seine Ergebnisse in einer festgelegten Zeitspanne liefern kann. Ein Fenster der grafischen Oberfläche öffnet sich nicht irgendwann, sondern garantiert eine Sekunde nach Anklicken. Echtzeitsysteme müssen nicht unbedingt schnell arbeiten, aber zeitlich zuverlässig.

338

Computern in Echtzeit

Mikrokernel-Systeme sind nicht auf Linux beschränkt. Auch Microsoft hat die Vorteile dieser Technik längst erkannt und bereits mit Windows NT ein System entwickelt, das man als Mikrokernel-System bezeichnen kann, wenigstens teilweise. Man spricht von Hybrid Mikrokernel. Andrew Tanenbaum, einer der größten Betriebssystem-Fachmänner, meinte dazu: »Windows NT 3.1 war ein halbherziger Versuch eines Mikrokernel-Systems, aber es wurde nicht richtig gemacht und die Leistung war nicht gut genug auf der Hardware der frühen 1990er Jahre, darum gab man die Idee erst einmal wieder auf.« Daher sind die neueren Windows-Versionen eigentlich noch weniger Mikrokernel-Systeme als Windows NT.

8.4


QNX wurde eben bereits erwähnt, nun wollen wir noch etwas näher auf dieses System eingehen. Wenn man es sich anschaut, könnte man es für eine ganz neue Entwicklung halten. Doch in Wirklichkeit reichen die QNX-Ursprünge bis 1980 zurück. Die beiden Erfinder, Dan Dodge und Gordon Bell, machten sich schon als Studenten an der Universität (Waterloo in Kanada) Gedanken über ein eigenes Betriebssystem. Es sollte ein Mikrokernel-System werden und in Echtzeit arbeiten. Bereits 1982 brachten sie mit ihrer Firma Quantum Software eine erste Version für den Intel 8088 heraus. In Kanada und für eingebettete Systeme verbreitete sich das System leidlich und wurde stets weiterentwickelt. Das zeigte sich auch äußerlich: Hieß es anfangs noch QUNIX, so taufte man es bald in QNX um, auch weil sich das einfacher aussprechen ließ. In den 90er Jahren passte man das System an Posix an, vor allem, damit man eine größere Palette an Software anbieten konnte. Die Firma nannte sich in QNX Software Systems um, wurde aber 2004 von Harman International übernommen – einer Firma, die hauptsächlich von Kfz-Beschallungselektronik lebt. Die Quelltexte des Systems wurden veröffentlicht, so dass man für den nichtkommerziellen Bereich beliebig daran herumprogrammieren kann. QNX bietet momentan die auf Eclipse aufbauende Entwicklungsumgebung kostenlos an. Daher ist das System nicht nur für Firmen interessant, die eingebettete Rechner herstellen, sondern auch für den Privatmann, der sich ernsthaft mit dem Aufbau von Betriebssystemen auseinandersetzen möchte. Und das nicht nur, weil es ein Echtzeitsystem ist, es ist auch eines der wenigen echten Mikrokernel-Systeme.

339

8.4

8


Das bedeutet, dass man Teilprogramme, aber auch Treiber während des laufenden Betriebs beliebig entfernen und installieren kann und sie ihre Arbeit zugleich einstellen oder, wenn sie installiert werden, aufnehmen.

Abbildung 8.10

QNX – das Echtzeitsystem

Was ist nun das Besondere an einem Echtzeitsystem? Versuchen Sie doch einfach mal, durch Starten mehrerer Programme das System in die Knie zu zwingen (siehe Abbildung 8.11). Merken Sie den Unterschied? Linux, vielleicht in Form von Ubuntu, verhält sich schon etwas anders als die gewohnten Betriebssysteme. QNX ist nun noch einen Schritt skalierbarer. Es arbeitet Nutzereingaben wesentlich konsequenter ab. Sie werden nicht erleben, dass Sie darauf warten müssen, einen Button drücken zu können, weil das System gerade etwas anderes macht. QNX ist, was Programme und die Befehle der Shell angeht, Linux sehr ähnlich. Das sollte Sie dazu anregen, ein wenig zu programmieren. Die Shell oder auch

340


die Konsole ist zwar nur ein Textfenster zum Entgegennehmen von Befehlen und erlaubt so das Arbeiten mit dem Betriebssystem, aber die sogenannten Shellskripte haben einen Befehlsumfang, der durchaus mit jeder echten Programmiersprache mithalten kann. Deshalb können wir hier auch keineswegs die ganze Skriptsprache vermitteln, sondern nur ein paar »Spielereien«, die die Möglichkeiten andeutungsweise zeigen. Praxis Das Programm kann man sich für eine zeitbegrenzte Testinstallation aus dem Internet ziehen; neben der Entwicklungsversion für Windows und Linux steht vom System allerdings nur ein Image für VMware zur Verfügung: http:// www.qnx.com/download/. Um das Image unter VMware starten zu können, kopieren Sie die entpackten Dateien in ein neues Verzeichnis, das Sie unter C:\users\\Documents\Virtual Maschines\ anlegen. Eingeloggt wird wie gehabt mit »root« und dem Passwort »root« oder ohne Passwort. Es erscheint eine etwas andere Oberfläche als bei Windows oder Linux. Diese nennt sich Photon microGUI, ist recht benutzerfreundlich und für ihre Leistungen erstaunlich klein. Wie bei den neuen Windows-Versionen (ab Windows NT) handelt es sich bei QNX um ein Mikrokernel-Betriebssystem. Es ist vor allem als sogenanntes Embedded System (eingebettetes System) in Gebrauch, also als System, das in Maschinen und Anlagen zur Steuerung genutzt wird. Wahrscheinlich wird es in Zukunft vor allem in Kraftfahrzeugen anzutreffen sein, zunächst aber eher zur Steuerung der Stereoanlage, bevor es uns irgendwann einmal das Lenkrad aus der Hand nimmt. Zuerst müssen Sie, sofern noch nicht geschehen, das System auf Deutsch umstellen, damit es mit der Tastatur keine Probleme gibt: Configure 폷 Localization. In diesem Dialog stellen Sie die Eintragungen unter Keyboard und Language auf Deutsch (German) um. Prüfen können Sie die Umstellung über Sidebar 폷 Utilities 폷 Terminal Charset Setup. Starten Sie danach eine Shell über die Sidebar 폷 Utilities 폷 Terminal. Ein Editor wird benötigt, um ein Skript schreiben zu können. Wir werden im Beispiel vi nutzen, obwohl er sehr gewöhnungsbedürftig ist. Wer gar nicht damit zurechtkommt, kann auch den grafischen Editor einsetzen: Applications 폷 Editor. Zunächst wechseln Sie in ein Home-Verzeichnis. In der Shell kann man die aktuelle Position im Verzeichnisbaum mit pwd abfragen. Falls Sie sich im Verzeichnis

341

8.4

8


/root befinden, können Sie dort bleiben. Sie können aber auch mit cd /home in das allgemeine Home-Verzeichnis wechseln. Mit vi hallo öffnen Sie die Datei für das Skript. Bei vi kann man nicht direkt losschreiben. Man muss zunächst ein a eingeben, um in den Edit-Modus zu gelangen. Tippen Sie nun folgende Zeilen ein (siehe Abbildung 8.11): while do echo "Hallo Coding For Fun" done

Abbildung 8.11

Terminal, grafischer Editor und Filemanager in QNX

Nun müssen Sie in den Kommando-Modus von vi. Das gelingt mit (Esc): Dabei springt der Cursor in die Kommandozeile am unteren Rand. Hier geben Sie ein x (¢) ein, und schon landet man wieder beim Shell-Prompt. Durch ls wird angezeigt, dass die neue Datei tatsächlich existiert. Nun müssen Sie erst die Rechte so setzen, dass man die Datei auch als Programm starten kann. Das gelingt mit chmod 777 hallo

Der Befehl bewirkt, dass alle Nutzer des Rechners die Datei hallo lesen, schreiben und starten können.

342

Noch mehr Spaß: OS/2 und gOS

Nun können Sie das Miniprogramm starten. Das gelingt mit der Eingabe von hallo und anschließendem Drücken der (¢)-Taste. Nun läuft das Programm in einer Endlosschleife und schreibt »Hallo Coding For Fun« unzählige Male auf den Bildschirm. Zur Unterbrechung dient die Tastenkombination: (Strg) + (C)

Ein interessantes Experiment wäre es nun, mehrere Terminals zu starten, in denen wir jeweils unser Programm laufen lassen, um dem System mal auf seinen »Echtzeit-Zahn« zu fühlen. Wer dagegen QNX mit C programmieren möchte, muss sich natürlich eine aktuellere Version im Internet besorgen. Der Buch-DVD wurden diese Versionen nicht beigelegt, weil sie zeitlich begrenzt sind. Wie bei Linux, so ist das auch bei QNX: Es gibt eine Open-Source-Version, die von einer freien Entwicklergemeinde weiterentwickelt wird.

8.5


8.5.1

OS/2

Bleibt noch zu erwähnen, dass IBM ab 1985 an einem »Gegner« für Windows arbeitete, dem Betriebssystem OS/2. Da Microsoft mit in die Entwicklung eingebunden war, bekam die Oberfläche das bewährte Windows-Flair. Nach der Trennung der Partner entwickelte IBM allein weiter, schaffte allerdings nicht den endgültigen Durchbruch, so dass OS/2 in die Mottenkiste der Softwaregeschichte wanderte. Natürlich haben sich die unermüdlichen Freaks auch dieses Systems angenommen und sind inzwischen dabei, es nach eigenem Gusto neu zu programmieren. Das Projekt nennt sich, wie könnte es anders sein, OSFree. Leider ist es noch nicht bis zur grafischen Oberfläche gediehen, so dass man sich im Grunde nur den Kern des Systems ansehen kann. Wer das einmal tun möchte, bevor wir uns weiter fortgeschrittenen Systemen zuwenden, dem sei diese Webseite empfohlen: http://www.osfree.org/. »OS/2 wird das Betriebssystem der 90er Jahre.« – Bill Gates

8.5.2

gOS

gOS wird von manchen für das angekündigte Web-Betriebssystem von Google gehalten, was es natürlich nicht ist. Es ist eher eine Art Netbook-System, denn die

343

8.5

8


Desktop-Oberfläche ist selbst auf kleinen Bildschirmen gut zu bedienen. »gOS Gadgets« heißt die aktuelle Version, was für »good Operating System« steht, also für »gutes Betriebssystem«. Entwickelt wurde es von der Firma gOS LLC in Los Angeles. Verkauft wurde es erstmals zum 1. November 2007 mit dem Everex Green gPC TC2502. Damals wurde der Rechner in den USA bei Wal-Mart für 199 $ angeboten. Innerhalb von zwei Wochen waren alle Rechner ausverkauft. »gOS Gadgets«, so wie es aktuell vorliegt, hat wirklich nichts von einem CloudSystem. Als Chimäre könnte man es freilich bezeichnen. Es besteht nämlich aus einem vollwertigen Ubuntu-System, in dem Anwendungen laufen, die sich der Rechner von Google aus dem Internet holen kann. Die Betaversion von gOS findet man im Internet momentan irrtümlicherweise unter dieser URL: http://getchrome.eu/download.php, aber auch hier: http:// www.thinkgos.com/. Die aktuelle Version gibt es ebenso auf der Buch-DVD: Software zum Buch\Kap8\ goodOS\gos-3.1-gadgets-20081205.iso. Es handelt sich um eine ISO-Datei, die man am besten auf eine CD brennt, bevor man sie zur Installation auf einer virtuellen Maschine nutzt. Wie das bei Betaversionen öfter der Fall ist, gelingt das nicht ohne Weiteres. Bei mir ging es ganz gut mit den Einstellungen für ein Ubuntu-System auf VMware (wen wundert's – gOS ist nur ein Ubuntu mit aufgepeppter Oberfläche). Die Installation läuft wie bei jedem Ubuntu ab. Nach einigen Voreinstellungen und dem Festlegen der Partition gibt man Name und Passwort des Nutzers an. Hier beginnt auch schon der eigentliche Installationsvorgang. Nach der Installation wird beim Start des Rechners der Logon-Bildschirm angezeigt. Klicken Sie Sitzung an, können Sie festlegen, welche Art von Desktop der Rechner öffnen soll – beispielsweise ein Terminal, um die Konfiguration zu reparieren/zu ändern (siehe Abbildung 8.12). Ein Teil der Programme, die mit Hilfe der Icons auf der Desktop-Oberfläche gestartet werden können, sind keine lokalen Programme, sondern GoogleAnwendungen, die aus dem Internet gestartet werden. Auf diese Weise ist das System besonders für Rechner geringerer Leistung interessant, weil man wesentlich mehr Programme greifbar hat, als auf der Festplatte installiert sind. Damit bildet gOS sozusagen eine Vorstufe zum kommenden Cloud-Betriebssystem (siehe Abbildung 8.13).

344


Abbildung 8.12

Einloggen in ein »gutes« Betriebssystem

Abbildung 8.13

gOS mit GIMP und Google maps

345

8.5

8


Gut gekontert Vor einigen Jahren hat Bill Gates auf einer Computermesse (der ComDex) die Computer-Industrie mit der Auto-Industrie verglichen und das folgende Statement abgegeben: »Wenn General Motors mit der Technologie so mitgehalten hätte wie die Computer-Industrie, dann würden wir heute alle 25-Dollar-Autos fahren, die 1.600 Meilen mit einer Gallone Benzin fahren könnten.« Als Antwort darauf veröffentlichte der General-Motors-Chef eine Presse-Erklärung mit folgendem Inhalt: »Wenn Gerneral Motors eine Technologie wie Microsoft entwickelt hätte, dann würden wir heute alle Autos mit folgenden Eigenschaften fahren: Ihr Auto würde ohne erkennbaren Grund zweimal am Tag einen Unfall haben. Jedes Mal, wenn die Linien auf der Straße neu gezeichnet werden würden, müsste man ein neues Auto kaufen. Gelegentlich würde ein Auto ohne erkennbaren Grund auf der Autobahn einfach ausgehen, und man würde das einfach akzeptieren, neu starten und weiterfahren. Wenn man bestimmte Manöver durchführt, wie z. B. eine Linkskurve, würde das Auto einfach ausgehen und sich weigern, neu zu starten. Man müsste dann den Motor erneut installieren. Man kann nur allein in dem Auto sitzen, es sei denn, man kauft »Car 95« oder »Car NT«. Aber dann müsste man jeden Sitz einzeln bezahlen. Macintosh würde Autos herstellen, die mit Sonnenenergie fahren, zuverlässig laufen, fünfmal so schnell und zweimal so leicht zu fahren sind, aber sie laufen nur auf 5 % der Straßen. Die Öl-Kontrollleuchte, die Warnlampen für Temperatur und Batterie würden durch eine »Genereller Autofehler«-Warnlampe ersetzt. Neue Sitze würden erfordern, dass alle dieselbe Gesäßgröße haben. Das Airbag-System würde »Sind sie sicher?« fragen, bevor es auslöst. Gelegentlich würde Sie das Auto ohne jeden erkennbaren Grund aussperren. Sie können nur wieder mit einem Trick aufschließen, und zwar müsste man gleichzeitig den Türgriff ziehen, den Schlüssel drehen und mit einer Hand an die Radioantenne fassen.

346


General Motors würde Sie zwingen, mit jedem Auto einen De-luxe-Kartensatz der Firma Rand McNally [seit neuestem eine GM-Tochter] mitzukaufen, auch wenn Sie diesen Kartensatz nicht brauchen oder möchten. Wenn Sie diese Option nicht wahrnehmen, würde das Auto sofort 50 % langsamer werden (oder schlimmer). Darüber hinaus würde GM deswegen ein Ziel von Untersuchungen der Justiz werden. Immer dann, wenn ein neues Auto von GM vorgestellt werden würde, müssten alle Autofahrer das Autofahren neu erlernen, weil keiner der Bedienhebel genau so funktionieren würde wie in den alten Autos. Man müsste den Startknopf drücken, um den Motor auszuschalten.« Im Jahr 2010 hatte es zumindest bei ein paar Automarken den Anschein, als wäre man auf dem besten Wege, Autos so zu bauen, wie es der Chef von GM damals in seiner Satire beschrieb. Vielleicht liegt das aber auch gerade daran, dass man Autos inzwischen immer mehr »computerisiert«.

8.5.3

Singularity – das Neueste aus dem Microsoft-Labor

Zur Ehrenrettung von Microsoft muss man sagen, dass sich seitdem viel getan hat. Beispielsweise hat man eine große Forschungsabteilung aufgebaut. Microsoft Research, abgekürzt MSR, wurde bereits 1991 gegründet und hat zahlreiche Neuentwicklungen vorangetrieben, unter anderem Programmiersprachen, wie F#, aber auch Ideen zu neuen Betriebssystemen. Eines der neuen Zöglinge ist ein Betriebssystem namens Singularity. Im Gegensatz zur üblichen Lizenzpolitik des Softwaregiganten hat man dieses System quelloffen gehalten und freigegeben, man kann es sich also herunterladen und versuchsweise installieren. Die aktuellste Version finden Sie stets unter http://singularity.codeplex.com/ releases. Sie befindet sich aber auch auf der DVD unter Software zum Buch\ Kap08\Singularity. Die Homepage des Systems ist http://research.microsoft.com/ en-us/groups/os/singularity/. Eine sehr schöne Diskussion über das System gibt es hier: http://sarwiki.informatik.hu-berlin.de/Singularity. Die Installation unter VirtualBox funktioniert nicht, man braucht Microsofts Virtual PC 2007, was es aber auch kostenlos gibt. Die VMC-Datei kopieren Sie in das Verzeichnis des neu eingerichteten virtuellen Rechners unter C:\Users\\Documents\Eigene virtuelle Computer\ Singularity. Die ISO-Datei aus dem Zip-Archiv muss man jetzt nur noch als CD ISO anhängen.

347

8.5

8


Abbildung 8.14

Singularity wartet auf Befehlseingaben.

Schon fährt das neueste Werk von MS hoch und zeigt sich mit königsblauem Hintergrund (siehe Abbildung 8.14). Natürlich möchte man nun auch etwas Programmähnliches laufen sehen. Wie man sich jedoch denken kann, ist das nicht ganz so einfach. Singularity kennt z. B. wie DOS ein dir-Verzeichnis, aber eine CD gibt es nicht. Braucht man auch gar nicht, man gibt immer den Pfad mit an, wo die gewünschte Datei liegt. Starten wir ganz einfach mal einen Benchmark-Test. Skripte werden im Gegensatz zu Programmen, mit dem Befehl script gestartet. script init/xbench.script

Es gibt zahlreiche weitere Skripts und etliche Programme, die noch der Erforschung harren. »Windows ist eindeutig ein Echtzeit-Betriebssystem. Wer damit arbeitet, muss echt Zeit haben!« – Anonymus

348

Lesen Sie weiter

8.6

Lesen Sie weiter


Beschreibung

http://www.chromium.org/chromium-os

Chromium-Betriebssystem-Homepage

http://www.levenez.com/windows/

Übersicht über die WindowsGeschichte

http://www.levenez.com/unix/

Übersicht über die UNIX-Entwicklungsgeschichte

http://de.wikipedia.org/wiki/ Cloud_Computing

Wikipedia-Seite über Cloud Computing

www.winhistory.de

Ansehen von alten Windows-Versionen

http://www.operating-system.org

Seite zu Betriebssystemen

http://www.winfaq.de/

Windows-FAQ-Seite

http://www.wi-inf.uni-essen.de/ ~schwarze/nt/nt.html

Seite zu Windows NT

http://www.ubuntu.com/

Ubuntu-Homepage

http://www.ubuntu.com/desktop/ get-ubuntu/download

Ubuntu-Download

http://ubuntuusers.de/

sehenswerte deutsche Ubuntu-Seite

http://www.thinkgos.com/

gOS-Homepage

http://www.bebits.com/app/2680

BeOS-Betriebssystem-Seite

http://www.haiku-os.org/

Haiku-Seite

http://de.opensuse.org/Herunterladen

Open SUSE-Download

http://www.knopper.net/knoppix/

Knoppix-Homepage

http://www.unix.org/

UNIX-Homepage

http://www.gnu.org/software/hurd/

das Hurd-Projekt

http://singularity.codeplex.com/releases

Singularity-Version

349

8.6

Kaum eine technische Entwicklung hat den Spieltrieb des Menschen so gereizt wie der Computer. Obwohl er bis heute nicht mehr als ein unscheinbarer Kasten geblieben ist mit nur wenigen Interaktionsmöglichkeiten und am Anfang nur grün leuchtende Texte hervorbrachte, reizte er von Beginn an die Kreativität seiner Schöpfer bis an ihre Grenzen. Es ist ein Rätsel, warum die Menschen sich so lange mit ihm abmühten, bis man mit ihm Strip-Poker spielen konnte. Vermutlich liegt es daran, dass er selten widerspricht, wenigsten im Allgemeinen.

9

Computerspiele

1952

1972

1981

1983 1984

2000

2009

OXO Pong Wolfenstein Mario Elite

Sims Americas Army

9.1

Es spielt der Mensch

Sätze wie Schillers »Der Mensch spielt nur, wo er in voller Bedeutung des Wortes Mensch ist, und er ist nur da ganz Mensch, wo er spielt«1 oder »Spielen ist so alt wie die Menschheit« sind nicht ganz korrekt, was man gleich bestätigen kann, wenn man schon einmal jungen Hunden und Katzen beim Spielen zugeschaut hat. Spielen ist also viel älter als das Menschsein. Es hat seinen Ursprung darin, dass wichtige Handlungen im Spiel erlernt, trainiert und erhalten werden. Wenn 1 Friedrich Schiller: Briefe über die ästhetische Erziehung des Menschen (1795), 15. Brief.

351

9

Computerspiele

man so will, kann man diesen Sachverhalt schon unter dem Okular eines Mikroskops finden, wo ein Einzeller sinnlos um ein paar Algen kreist und dadurch dem nächsten Angriff eines Wasserflohs entgeht. Spiel ist es dadurch, dass ihm der Ernst der Lage fehlt. Dem »Sinn« im Spiel der Tiere hat der Mensch das »sinnlose« Spielen zu Unterhaltungszwecken hinzugefügt, indem er zahlreiche Spiele jeder Art hinzuerfand. Vom Gesellschaftsspiel über das Geschicklichkeitsspiel bis zum Computerspiel gibt es kaum einen Lebensbereich, der das Spiel nicht kennt. Nach wie vor gibt es für Spiele zahlreiche Daseinsberechtigungen. Neben dem reinen Zeitvertreib (Brettspiele) dient es dem Broterwerb (Wetten), kann das Lehren und Lernen fördern (Lernspiele) oder stärkt körperliche Fähigkeiten (Sportspiele). Und nach wie vor hat Spielen seine erste Bedeutung, die es bereits in der Tierwelt hatte, behalten.

9.2

Der Computer lernt spielen

Bereits vor dem Computer gab es ein erstes Videospiel. Thomas Toliver Goldsmith, der später eine Physikprofessur an der Furman University in Greenville innehatte, ließ sich 1948 zusammen mit Estle Ray Mann das U.S.-Patent 2,455,992 ausstellen, das den Namen »Cathode Ray Tube Amusement Device«2 trug. Im Krieg war ihnen bei der Arbeit mit Bildröhren an Radargeräten aufgefallen, dass man mit dem Strahl, durch Drehknöpfe gesteuert, Spuren wie Geschossflugbahnen auf dem Monitor erzeugen konnte. Steckte man Landschaftsbilder vor den Schirm, ergab das eine Art Raketenschießspiel. Das Gerät ging nie in Serie, gilt heute aber als erstes Videospiel – wenn auch noch ohne Computer.

9.2.1

Ein Spiel, ein Computer – Nimrod

1951 trat der Computer jedoch mit einem Paukenschlag in die Welt der Spiele ein. Mit Nimrod wurde in England ein Computer gebaut, der keine andere Aufgabe hatte als das Spiel Nim zu spielen. Er war einer der Höhepunkte auf dem Festival of Britain, das so kurz nach dem Krieg die Engländer für den Wiederaufbau motivieren sollte. Geliefert wurde er von der Firma Ferranti, die im gleichen Jahr ihren kommerziellen Rechner Ferranti Mark I vorstellte. Praxis: Das erste Computerspiel Natürlich gibt es Computersimulationen vom ersten Computerspiel in den verschiedensten Ausführungen. Eine Version für Windows findet man unter 2 Kathodenstrahlröhren-Spieleinheit

352


http://www.freeware.hartberg.info/freeware.php?programm=25&seite=5. Es gibt sie aber natürlich auch auf der DVD unter Software zum Buch\Kap09\Nim\ Streichholz30.exe. Es handelt sich um ein Windows-Programm, das die Streichhölzer realistisch darstellt, aber nur mit einer Reihe arbeitet. Nach dem Start des Programms kann man zunächst einmal auswählen, ob der Rechner beginnt oder man selbst. Ersatzweise kann man auch gegen einen menschlichen Gegner spielen. Wie auch immer man beginnt, man wird bald merken, dass das Spiel nicht so einfach ist, wie es ausschaut – zumal, wenn man ein ungeübter Nim-Spieler ist.

Abbildung 9.1

Nim mit Streichhölzern

Und das, obwohl Nim ein sogenanntes Spiel mit vollständiger Information ist, was bedeutet, dass es keine Zufälle gibt und der Zug des Gegners sichtbar stattfindet oder sogar vorhersehbar ist. Ist ein solches Spiel zeitlich überschaubar, kann man es mit einer einfachen Strategie gewinnen. Mit der richtigen Strategie kann man folglich alle »Spiele mit vollständiger Information« gewinnen. Spiele wie Schach dagegen sind so komplex, dass man die richtige Strategie, sofern man sie denn hätte, in der zur Verfügung stehenden Zeit nicht umsetzen kann. Nim ist nun wesentlich einfacher gestrickt. Wer es nie gespielt hat, wird wahrscheinlich Probleme haben, es auf Anhieb zu gewinnen. Zumindest, solange er noch keine richtige Strategie hat. Damit wollen wir uns noch beschäftigen. 353

9.2

9

Computerspiele

Nims Einfluss auf die Spieltheorie Die Überlegungen bezüglich des Nim-Spiels beeinflussten die neuere Spieltheorie, die John von Neumann mitprägte und die im Bereich des wirtschaftlichen Handelns eine große Rolle spielte. Untersuchungen zur Spieltheorie waren damals mit ein Grund dafür, den Nimrod-Rechner zu bauen.

Um das Spiel besser zu verstehen, sehen wir uns ein Nim-Programm einmal genauer an. Es ist etwas anders aufgebaut, vom Spielablauf jedoch gleich. Das Spiel befindet sich auf der Buch-DVD unter Software zum Buch\Kap09\Nim\ NimMaster01.jar. Zum Starten muss Java installiert sein. Sie starten mit einem Doppelklick oder aus der Konsole mit Hilfe von java -jar NimMaster01.jar

Das einfache, textorientierte Programm zeigt die Streichhölzer als senkrechte Striche in fünf Reihen:

Abbildung 9.2

»NimMaster01« zeigt fünf Reihen Streichhölzer.

Zunächst gibt man die Zeile ein, aus der man Streichhölzer entnehmen möchte, und dann die Anzahl der Streichhölzer, die man nimmt. Das in Java geschriebene Spiel liegt auch als Quellcode in Form eines Eclipse-Projekts auf der DVD unter Software zum Buch\Kap09\Nim\NimMaster01. Es besteht nur aus zwei Klassen. Die Klasse Zug dient lediglich dazu, das Double aus Zeile und Anzahl zusammenzufassen, das einen Zug ausmacht. Der Rest des Codes liegt ganz in der Klasse Nimrod.

354


Die Strategie steckt in der Methode werten mit der rekursiven Suche nach dem optimalen Zug. Hierzu wird jede Reihe von 1 an durchlaufen und versuchsweise ein Streichholz nach dem anderen weggenommen, getestet, ob der Spielstand einen Gewinnzustand darstellt oder einen unbestimmten Zustand. Schließlich wird das Streichholz wieder hinzugepackt. Diese Schleife sieht folgendermaßen aus: for (int i = 0; i < reihe.length; i++) { if (testDopplungen(reihe, i)) continue; for (int tmp = 1; tmp value) value = v; if (!isMax && v < value) value = v; legeHin(reihe, i, tmp); } }

Ausgewertet wird mit Hilfe der if-Abfragen, die man zusammenfassen kann zu if ((isMax && v > value) || (!isMax && v < value))

Es geht sogar noch eine Nummer eleganter. Diese Lösung ist in Form der NimMaster02-Datei ebenfalls auf der DVD abgelegt: Software zum Buch\Kap09\ Nim\NimMaster02.jar. Dieses Programm kommt mit wesentlich mehr Streichholzreihen zurecht. Man kann sie in Java einfach vergrößern, außerdem ist eine Zufallsfunktion eingesetzt, die für jede Reihe eine zufällige Anzahl von Hölzchen auswählt (siehe Abbildung 9.3). Der Code ist ebenfalls wieder auf der DVD unter Software zum Buch\Kap09\ Nim\NimMaster02. Außerdem sieht die Strategiemethode etwas anders aus: int bewerten(int reihe[], boolean isMax) { int retValue = 0; int reg = 1; String text = ""; retValue = (isMax) ? 1 : 0; for (int i = 0; i < reihe.length; i++)

355

9.2

9

Computerspiele

{ retValue = retValue ^ reihe[i]; if (reihe[i] != 0) { reg *= reihe[i]; } text = text + "; " + reihe[i]; } if (retValue > 0) retValue = 0; else retValue = 1; if (reg == 1) if (retValue > 0) retValue = 0; else retValue = 1; return retValue; }

Entscheidend ist die Zeile retValue = retValue ^ reihe[i].

Abbildung 9.3

356

NimMaster02 mit Zufallsfunktion und sieben Streichholzreihen


Hiermit werden die binären Ungeraden über alle Streichholzreihen gesucht. Sind alle gerade, ergibt sich für retValue == 0. Das ist die Win-Situation. Enthalten alle Reihen nur noch ein Streichholz, muss man etwas anders verfahren. Somit wird die bewerten-Methode einfacher und die Rekursion entfällt, was das Programm auch wesentlich schneller macht. Wer sich die Strategie noch genauer ansehen möchte, sollte sich den Artikel zu Nim in Wikipedia durchlesen: http://de.wikipedia.org/wiki/Nim-Spiel. Zur gleichen Zeit, als Nimrod sein Nim-Spiel spielte, also 1952, gab es einige Brettspiele, die von enthusiastischen Informatikern auf den vorherrschenden Großrechnern realisiert wurden. Im gleichen Jahr wurde OXO programmiert, eine Tic-Tac-Toe-Version.

9.2.2

OXO

Die ersten Computerdisplays waren nicht mehr als Kathodenstrahlröhren. Auf ihnen wurden auch die ersten grafischen Spiele überhaupt gespielt. 1947–1948 war es Cathode Ray Tube Amusement Device, das Raketen simulierte. Das nächste grafische Spiel, das auf einem Computer gespielt wurde, war OXO. Es ist auch unter dem Namen »Noughts and Crosses« bekannt und nichts anderes als eine Computerversion von Tic-Tac-Toe. A. Sandy Douglas entwickelte es bereits 1952 auf dem EDSAC-Computer. Diese sehr interessante Maschine besaß Kathodenstrahlröhren zur Ergebnisausgabe und eine Anzeige der Speicherinhalte sowie eine Telefonwählscheibe zur Eingabe von Zahlen. Aber was sage ich, schauen wir uns diese Höllenmaschine einfach einmal an (siehe Abbildung 9.5). Sie ist im Internet zu finden unter http:// www.dcs.warwick.ac.uk/~edsac/. Auf der Buch-DVD liegen Versionen für Windows, Linux und Apple in diesem Verzeichnis: Software zum Buch\Kap09\Edsac. Über die Schaltfläche Software lässt sich die EDSAC-Simulation downloaden. Sie ist für verschiedene Systeme verfügbar. Wenn man genauere Informationen haben möchte, sollte man nicht vergessen, die Dokumentation ebenfalls zu ziehen, sie liegt auch auf der DVD. Die Programmierung dieses Rechners ist sehr schwierig, deshalb wird hier nicht darauf eingegangen. Das beiliegende OXO-Programm laden Sie mit Hilfe von File 폷 Open von der DVD, und zwar unter Software zum Buch\Kap09\OXO\OXO.txt.

357

9.2

9

Computerspiele

Abbildung 9.4

EDSAC-Simulation

Ein zusätzlicher Dialog wird geöffnet, in dem das Programm angezeigt wird. Starten können Sie es nun durch Anklicken der Schaltfläche Start. Der Drucker gibt eine Lademeldung aus.

Abbildung 9.5

Das Spiel OXO von 1952

Um das Spiel zu spielen, wählen Sie erst einmal auf der Wählscheibe die 1 für Start beim Nutzer oder die 0 für Start beim Computer (siehe Abbildung 9.5). Nun können Sie die Nummer des Feldes wählen, in dem Sie einen Stein setzen möchten. Die Nummerierung der Felder wird links vom Programmtitel angezeigt. Sie ist:

358

Mit Pingpong fing es an

9 8 7 6 5 4 3 2 1

Tic-Tac-Toe spielt übrigens im Hollywood-Streifen Wargames eine große Rolle. OXO ist wie Tic-Tac-Toe ein Spiel mit vollständiger Information. Wenn man keine Fehler macht, kann man nicht verlieren. Das ist einfach und fällt nicht sonderlich schwer. Es macht deutlich, was man unter einem Spiel mit vollständiger Information versteht. Natürlich war OXO noch kein Spiel für die Allgemeinheit – der EDSAC war einer von gerade mal fünf Computern, die es damals gab, und jede dieser Maschinen war ein absolutes Unikat. Elektronische Spiele für alle sollten erst Jahrzehnte später folgen. Der erste Monitor im Homecomputerbereich war der Fernseher. Dieser hatte die überwältigende Auflösung von 640 × 480 Punkten, meist sogar wesentlich weniger. Wen wundert es, dass die ersten Spiele auf den Homecomputern recht grobe Klötze waren? Noch vor dem Computer waren Spielkonsolen auf den Markt gekommen, die den Fernseher bereits spieltauglich machten. Das erste wirklich erfolgreiche Spiel, an dem sich alle versuchen wollten, hieß Pong und war eine wirklich »klotzige« Tennis-Simulation. Es gab einen quadratischen Ball, der hin und her sprang, und rechteckige Schläger, die man mit einem Schieberegler oder einem Drehpoti (Paddle) auf und ab bewegen konnte. Schauen wir uns das doch einmal an.

9.3


Pong hieß das erste erfolgreiche Grafik-Computerspiel. Der Erfinder war ein gewisser Ralph Baer, ein Deutschamerikaner, der sich außerdem Senso, ein musikalisches Gedächtnisspiel, ausdachte. Das Spiel wurde 1972 von Magnavox, einer ehemaligen Lautsprecherfabrik, auf den Markt gebracht. Den Namen Pong musste man wählen, weil Pingpong schon geschützt war. Später übernahm die frisch gegründete Firma Atari die Spielidee und realisierte damit ihre ersten großen Umsätze.

Sie finden eine Java-Version auf der DVD unter Software zum Buch\Kap09\Pong\ PingPong.jar. Gestartet wird aus der Konsole mit java -jar PingPong.jar

359

9.3

9

Computerspiele

Es handelt sich um eine einfache Version des Spiels. Gezählt werden nur die Schlägerberührungen des Balls. Die Realisation in Java erlaubt nur eine vertikale Schlägersteuerung, mit den Tasten (½) und (¼) und mit den Tasten (Y) und (A).

Abbildung 9.6

Das Spiel Pingpong als Remake des Urspiels Pong

Praxis: Pong in Java Im gleichen Verzeichnis befindet sich auch der Java-Quellcode als Eclipse-Projekt. Sie werden sehen, dass der meiste Code für die Darstellung der Ziffern des Zählwerks erforderlich ist. Genauso war es auch bei der ersten Version damals, nur, dass diese nicht in Java programmiert, sondern mit Hardware realisiert war. Zunächst gibt es einmal eine Variable, die bei Berührung der Schläger hochgezählt wird. Die Zahl wird in einen String umgewandelt und in die erste und zweite Ziffer zerlegt. Danach können die einzelnen Ziffern digitalisiert werden. In einer Liste wird festgehalten, welcher von den sieben Balken leuchten sollen. /* * * Anordnung der Balken für die Ziffern * * 4 * 0 5 * 3 * 1 6 * 2 */

360


private void digitize(int zahl) { digitNull(); switch (zahl) { case 0: digit[0] = true; digit[1] = true; digit[2] = true; digit[4] = true; digit[5] = true; digit[6] = true; break; case 1: digit[5] = true; digit[6] = true; break;

Am Ende werden die jeweiligen Balken der Digitalanzeige gezeichnet. private void zeichneLine(Graphics g, int zahl) { switch (zahl) { case 0: paintYBalken(g, 0, 0); break; case 1: paintYBalken(g, 0, 20); break; case 2: paintXBalken(g, 0, 40); break; case 3: paintXBalken(g, 0, 20); break; case 4: paintXBalken(g, 0, 0); break; case 5: paintYBalken(g, 20, 0); break; case 6: paintYBalken(g, 20, 20);

361

9.3

9

Computerspiele

break; } }

Das Spiel selbst ist einfach zu programmieren. Sobald der Ball eine Grenze erreicht, und das ist sowohl der Rand des Spielfelds als auch der Schläger, wird er um 90 Grad abgelenkt. Das gelingt, indem wir zur Seite weglaufen. An der oberen X-Grenze laufen wir +Betrag nach Y, an der unteren einen MinusWert(-Betrag). Actionspiele dieser Art wurden immer weiter perfektioniert, bis zu Versionen, die eine annähernd realistische Welt zeigen, in der der Spieler sich bewegt. Es werden heute Spiele angeboten – beispielsweise für die Spielkonsole Wii von Nintendo –, die versuchen, auch die Bewegungen des Spielers beim Tennis oder anderen Spielen möglichst realitätsnah zu erfassen, um das Spielerlebnis zu vervollkommnen. Das wird erreicht, indem man in die Controller Bewegungssensoren einbaut, die die Bewegungen im Raum erfassen.

9.3.1

Auf ins All!

Spiele mit so niedriger Auflösung, wie bei OXO oder Pong, besaßen natürlich kaum grafische Reize. Das wurde 1961 alles anders. Am MIT (Massachusetts Institute of Technology) machte sich der Programmierer und KI-Fachmann Stephen R. Russell mit einem PDP-1 und seinen Kumpanen Martin Graetz und Wayne Wiitanen daran, ein Spiel namens Spacewar fertigzustellen. Dem MIT ging es darum zu zeigen, was ein PDP kann, und dafür schien, wie schon 10 Jahre zuvor beim Nimrod, ein Spiel am besten geeignet. Zu jener Zeit war man einfach Lensman-Fan und verschlang die Science-FictionRomane von Edward E. Smith nur so. Also stand für die drei fest, es musste ein Weltraumspiel werden. Im Weltall ging es um Sterne und schwarze Löcher, also würde ein Raumschiff in das Gravitationsfeld einer überschweren Sonne geraten und abstürzen. Außerdem wurde im Weltall ständig geschossen. Ein zweites Raumschiff musste her. Die Sonne war zu umkreisen. Auch die Geschosse mussten natürlich der Schwerkraft der Sonne unterliegen. Ein Treffer bedeutete den Untergang, aber ebenso der Sturz in die Sonne. Ganz wichtig war auch der Nachlaufeffekt bei der Raumschiffsteuerung. Was bedeutet, dass die Raumschiffe etwas verspätet reagieren. Außerdem war es im Weltall doch so: Hatte man erst mal beschleunigt, blieb die Geschwindigkeit aufgrund des fehlenden Luftwiderstands für ewig erhalten, zum Abbremsen musste man erst einmal in die entgegengesetzte Richtung beschleunigen. Alles Sachverhalte, die das Spielen mit den Raumschiffen nicht gerade vereinfachten, das Spiel selbst jedoch interessant machten. 362


Am Ende hatten sie ein für heutige Verhältnisse sehr einfaches Spiel entwickelt, das trotzdem seinen ganz besonderen Reiz hatte – was auch der Grund dafür ist, dass es bis heute gespielt wird. Praxis: Spacewar Natürlich gibt es das Originalspiel von 1961 im Netz zu bewundern. Die Webseite ist http://spacewar.oversigma.com/. Man kann es direkt im Internet als Applet spielen. Es gibt außerdem einen PDP1-Emulator in Java, mit dem man das Programm lokal laufen lassen kann. Sie finden ihn auf der DVD unter Software zum Buch\ Kap09\Spacewar\SpaceWar.jar. Der Quellcode für die PDP-Simulation befindet sich als Eclipse-Projekt unter Software zum Buch\Kap09\Spacewar\Pdp1. Gestartet wird Spacewar, wie alle Java-Jars, durch java -jar SpaceWar.jar

Wobei darauf zu achten ist, dass die PDP1-Datei spacewar.bin im gleichen Verzeichnis liegt.

Abbildung 9.7

Spacewar – das Original von 1961 in einem Java-PDP1-Simulator

363

9.3

9

Computerspiele

Das Spiel wird mit den Tasten (A), (S), (D), (F) für die dicke Rakete gesteuert und mit (K), (L), (;), ('). Die Anziehungskraft der Supernova ist sehr groß, daher macht es wenig Sinn, den Antrieb gegen den Stern zu richten und zu versuchen, seiner Gravitation zu entfliehen. Es ist einfacher, die Gravitation zu nutzen und in einer Art Swing-byVerfahren die Beschleunigung auf den Stern zu mit dem Antrieb noch zu erhöhen und dicht daran vorbeizufliegen. Außerdem muss man berücksichtigen, dass nur begrenzt Munition vorhanden ist. Wenn man nach etwas Übung den SpieleOldtimer beherrscht, kann er durchaus Spaß machen, und das am meisten, wenn man zu zweit spielt. Dass Spacewar auch heute noch ein modernes Spiel sein kann, möchte ich anhand einer Micro-Edition-Version zeigen. Die Java Micro Edition ist ein JDK für Java-Handys, PDAs u.Ä. Man findet sie unter folgender Seite im Internet: http://java.sun.com/javame/downloads/index.jsp. Von dort kann man beispielsweise für Windows eine exe-Datei beziehen, mit der man das JDK sowie ein Entwicklungssystem auf dem heimischen Rechner installiert bekommt. Die Software finden Sie aber auch auf der DVD unter Software zum Buch\Kap09\Java Microedition3\sun_java_me_sdk-3_0-win.exe. Die Installation sollte nicht weiter problematisch sein.

Abbildung 9.8

Start der IDE der Micro Edition

Bei der Installation wird ein Start-Icon auf der Desktop-Oberfläche abgelegt, mit dem man die NetBeans ähnliche Entwicklungsumgebung starten kann. Wer schon einmal mit NetBeans oder Eclipse entwickelt hat, findet sich rasch mit der ME-Plattform zurecht.

364


Um den Quellcode von Spacewar übersetzen zu können, sollte man ihn zunächst von der DVD auf ein Verzeichnis der Festplatte entpacken. Er liegt unter Software zum Buch\Kap09\ME-SpaceWar\SpaceWar.zip. Wichtig ist, das SpaceWar-Verzeichnis in der Zip-Datei beizubehalten. Nun können Sie das Projekt über File 폷 New Project 폷 Import Wireless Toolkit Project mit der Next >-Schaltfläche importieren. Dabei wählen Sie das SpaceWar-Verzeichnis im Feld WTK Location: mit der Browse...-Schaltfläche aus. Nach dem Anklicken der Next >-Schaltfläche sollte man darauf achten, dass Set as Main Project aktiv ist. Die Einstellungen auf der nächsten Seite sind noch wichtiger, damit man das Spiel auf zwei Handys ablaufen lassen kann. Diese Einstellungen sind: Emulator Plattform: CLDC Java(TM) Platform Micro Edition SDK 3.0 Device: DefaultCldcJtwiPhone1 Device Configuration: CLDC-1.0 Device Profile : MIDP-2.0

Nun kann man mit Finish den Importvorgang abschließen. Gestartet wird jetzt keineswegs über die Start-Schaltfläche, sondern mit Hilfe der virtuellen Handys, die man unter Device Selector findet.

Abbildung 9.9

Phone2 mit Spacewar starten

Und zwar startet man DefaultCldcJtwPhone1 über die rechte Maustaste mit Run Project und DefaultCldcJtwPhone2. Wundern Sie sich nicht darüber, dass das Projekt nun plötzlich Battlecruiser heißt. Die beiden Handys kommunizieren direkt nach dem Start miteinander, und das Multiuserspiel kann beginnen (siehe Abbildung 9.10). Eine genaue englische Beschreibung zu diesem ME-Projekt gibt es im Internet unter http://developers.sun.com/mobility/midp/articles/gamepart2/.

365

9.3

9

Computerspiele

Abbildung 9.10

9.3.2

Handy-Spacewar: unter starkem Beschuss

Nicht nur reine Ballerei

Bevor wir uns die weitere Entwicklung in zeitlicher Folge ansehen, werfen wir einen kurzen Blick auf die einzelnen Spielegattungen. Das dürfte hilfreich sein, um zu verstehen, wie und warum die verschiedenen Spiele sich nach und nach entwickeln konnten. Die Gruppierung stellt dabei keine anerkannte Norm dar, denn es gibt viele Zwischenformen, und manchmal ist die Zuordnung schwierig. »Ich wollte zuerst etwas über deine dünnen Ärmchen sagen. Aber dann fiel mir deine hässliche Visage auf.« – Aus Gothic Ballerspiel Ballerspiele sind im Grunde die elektronische Version der Schießbude auf dem Jahrmarkt. Sie sind zu den Geschicklichkeitsspielen zu rechnen. Es handelt sich um eine der ältesten Computerspielformen, dessen erste Vertreter Cathode Ray

366


Quelle: www.funny-games.biz/morhun.html

Tube Amusement Device als erstes Videospiel und Spacewar als erstes digitale Computerspiel überhaupt gelten. Besonders bekannte Vertreter sind Moorhuhn und als Mischformen Wing Commander und Doom. Trotz der hohen Beliebtheit hält sich der Spielreiz in Grenzen, weil es schnell langweilig wird, immer nur zu schießen. Aus diesem Grund gibt es auch zahllose Abwandlungen dieser Spielidee. So werden Adventurespiele durch Schießkampfszenen zu ActionadventureSpielen, und Strategiespiele haben als Entspannungs- oder Anspannungselemente Schießszenen eingebaut. Die sogenannten 3D-Shooter sind aktuell die am weitesten entwickelten Ballerspiele.

Abbildung 9.11

Ein Kult-Ballerspiel: Online-Moorhuhn-Spiel

Die Webseite von Moorhuhn finden Sie hier: http://www.funny-games.biz/ morhun.html. Geschicklichkeitsspiel Vom Ballerspiel war es nur ein logischer Schritt zum Geschicklichkeitsspiel. Diese Spielform gab es lange vor dem Computer, und sie zählt zu den ersten Spielformen überhaupt. Einerseits wurden einfach Spiele aus der Realität in den Computer übertragen, andererseits entwickelte man ganz neue Formen, die auf der Beherrschung der Cursorsteuerung (Joystick, Maus) und der Tastatur beruhten. Eine spezielle Unterform ist das »Jump and Run«-Spiel, von dem es sehr viele gibt. Bekannte Vertreter sind Q-Bert, Pinball, Donkey Kong, Super-Mario. Auch bei dieser Spielart gibt es zahlreiche Abwandlungen. Oft werden Adventure-

367

9.3

9

Computerspiele

spiele mit Geschicklichkeitsspielen gekreuzt, wie man das beispielsweise bei Unreal gemacht hat.

Abbildung 9.12

Ein »Jump and Run«-Spiel: Super-Mario als Onlinespiel »Mario Time Attack«

Die Webseite von Super-Mario gibt's hier: http://www.onlinespielex.de/tags/ mario/. Strategiespiel/Simulationsspiel Was manuelle Geschicklichkeit übersteigt, ist Strategie. Bei diesen Spielen kommt es darauf an, sich eine Vorgehensweise zu erarbeiten, um damit zu siegen. Strategiespiele erlebten durch den Computer einen regelrechten Boom. Das hat viele Gründe. Etliche Spiele erfordern viel Aufwand, wenn man sie ohne Computer spielt, z. B. mililärische Sandkastenspiele und Simulationsspiele aller Art. Für andere Spiele fehlt oft der gleichwertige Spielpartner, z. B. beim Schach. Dies alles kann ein Computerprogramm ausgezeichnet übernehmen. Aber auch ganz neue Arten von Strategiespielen entstanden wie SimCity und Anno 1602, die zu den Wirtschaftssimulationen gehören und ohne Computer eigentlich nicht möglich sind. Später entwickelten sich daraus LebensumfeldSimulationen, wie die Sims, die ein Familienleben im Computer simulieren. Diese Spiele waren und sind bei Jungen und Mädchen gleichermaßen beliebt. Eine weitere Unterkategorie sind Strategiespiele mit militärischem Hintergrund. Das reicht vom einfachen Panzerspiel Panzer General bis America's Army, einem sogenannten 3D-Shooter, der als Werbung für die Army gedacht ist.

368


Besondere Vertreter sind: Die Sims, Lemmings, Battle Chess, SimCity, Panzer General und America's Army.

Abbildung 9.13

LinCity – eine freie SimCity-Variante

Rollenspiel Von allen Spielen sind Rollenspiele die anspruchsvollste und beliebteste Spielform, wenn man einmal von komplexen Strategiespielen, wie Schach, absieht. Rollenspiele sind ebenfalls bereits sehr alt. Wenn wir unser Leben als Rollenspiel betrachten, sind sie das älteste Spiel überhaupt. Wer hat nicht als Kind Räuber und Gendarm, Ritter oder Cowboy und Indianer gespielt? Man schlüpft in eine Rolle, und die Welt um einen herum ändert sich. Ein einfacher Stock wird zu einem Schwert, ein Papierhut zur Krone. Zum Spiel gehört eine gehörige Portion Phantasie und schauspielerische Ausdruckskraft. Auch hier kann ein Computer Schützenhilfe leisten. Er lässt uns zumindest auf einer Fläche mit 19"-Diagonale in die Welt blicken, die wir uns sonst mühsam vorstellen müssten. Wobei es das Rollenspiel an sich im Computer eigentlich gar nicht gibt, wenn wir mal eine Online-Infrastruktur wie Second Life nicht als Spiel ansehen. Nur eine Rolle spielen macht im Computer keinen Spaß, falls es nicht andere Leute gibt, die mit einem zusammen das Rollenspiel spielen. Rollenspiele sind demnach immer Adventure- oder Actionspiele oder irgendein anderes Spielgenre. Sie werden hier trotzdem erwähnt, um Online-Infrastrukturen und Spiele richtig eingliedern zu 369

9.3

9

Computerspiele

können. Das heute erfolgreichste Rollenspiel und gleichzeitig Action- und Adventuregame ist World of Warcraft.

Abbildung 9.14

WoW – World-of-Warcraft-Rolle »Superzwerg«

»Zu den Nebenwirkungen zählen trockener Mund, Übelkeit, Erbrechen, Harnstau, schmerzhafter rektaler Juckreiz, Halluzinationen, Demenz, Psychose, Koma, Tod und Mundgeruch. Magie eignet sich nicht für alle. Fragt euren Arzt oder Apotheker.« – aus World of Warcraft Adventuregame Adventuregames sind eigentlich immer Rollenspiele. Man schlüpft in die Haut eines Abenteurers oder einer Abenteurerin (z. B. Lara Croft, siehe Abbildung 9.15). Danach gilt es der Spielidee entsprechende Abenteuer zu bestehen. Vor der Zeit der Grafikadventures waren dies meist Reisen oder die Suche nach bestimmten Dingen (Schätzen). Mit grafisch dargestellten virtuellen Welten eröffneten sich ganz neue und schier unbegrenzte Möglichkeiten. Welten, die man in Textadventures seitenlang hätte beschreiben müssen, sind jetzt mit einem Blick zu erfassen. Ein weiterer Meilenstein waren die 3D-Egoshooter, die Grafiken für die Darstellung der virtuellen Welten nicht mehr nur vom Datenträger laden, sondern selbst errechnen. Diese Rechenarbeit muss natürlich in Echtzeit

370


oder wenigstens annähernd in Echtzeit erfolgen, damit der Eindruck einer echten Wirklichkeit im Monitor nicht verloren geht. Neben hochwertigen CAD-Anwendungen war dieser Anspruch der Hauptgrund für die Grafikkarten-Industrie, immer bessere Produkte zu entwickeln. Actionadventure Action steht, wie wir seit Gouverneur Schwarzenegger wissen, für Einsatz, aktives Handeln und Abenteuer. Fordert ein Abenteuerspiel vom Spieler in hohem Maße den Einsatz von Maus oder Joystick und dabei insbesondere die Feuertaste, sprechen wir vom Actionadventure. Sie stellen die Mehrzahl der heute gespielten Computerspiele. Viele MMORPGs sind Actionadventures. Ein typischer Vertreter dieses Spielegenres ist Tomb Raider (siehe Abbildung 9.15). Eine Untergruppe der Actionadventures sind die Sportspiele. Wichtige Vertreter sind Pole Position und Summer/Winter Games. Wenn man so will, kann man die Aktivitäts- und Bewegungsspiele, die mit der Wii-Spielkonsole aufgekommen sind, zu einem großen Teil auch zu dieser Spielgattung zählen, verwirklichen sie immerhin Action im eigentlichen Sinne.

Abbildung 9.15

Tomb Raider

MMORPGs Diese Gattung gehört eigentlich nicht in diese Aufzählung, weil sie kein Spielegenre, sondern eine technische Spielart ist. MMORPG steht für Massively Multiplayer Online Role-Playing Game. Sie entwickelte sich nach und nach aus Spielen, die man im engeren Kreis eines privaten Netzwerks spielen konnte. Mitentschei-

371

9.3

9

Computerspiele

dend war die Persistenz, das Speichern des aktuellen Spielzustands. Vorher wurde dies durch einen Level gelöst, in dem der Spieler sich befand und in dem er sich wiederfand, wenn er das Spiel erneut startete. Diese Lösung war bei MMOGs (Massively Multiplayer Online Game) nicht mehr möglich, es sei denn, die Spieler bildeten eine Gruppe, die alle Abenteuer gemeinsam meisterten. Nicht nur, dass ein solches Spiel weiterläuft, auch wenn sich ein Spieler abmeldet, dieser muss auch wieder in das Spiel hineinfinden können, wenn er sich erneut einloggt.

Abbildung 9.16

Das MMOG Cabal

Mit dem Siegeszug des Internets wurden aus den Multiplayer Games MMPGs, Massive Multiplayer Games, mit Millionen von Mitspielern. Obwohl wir natürlich auch World of Warcraft dazuzählen müssen, sind die meisten dieser Spiele heute Browserspiele. Man braucht keine zusätzliche Software, und jeder der ins Internet gehen kann, kann auch bei einem solchen Spiel mitspielen. Das eigentliche Spielgeschehen wird dadurch in Serverfarmen verlagert, und der heimische Browser dient lediglich dazu, die Daten anzuzeigen und die Spielszenen zu animieren. Oft fordern die Betreiber solcher Spielnetzwerke eine monatliche Gebühr oder ein ähnliches Salär, um die aus dem Serverbetrieb rührenden Unkosten zu begleichen.

372


Praxis: Die Welt der Strategien Spiele, bei denen es darum geht, ganze Welten zu planen oder durch Handelsstrategien zu erobern, gibt es inzwischen wie Sand am Meer. Trotzdem war es nicht einfach, ein Spiel zu finden, dass einem der großen Meilensteine der Computer-Spielkultur nachempfunden und frei erhältlich ist. Glücklicherweise gibt es ein solches Spiel, es heißt LinCity und ist eine Simulation à la SimCity. SimCity selbst wurde 1989 von der Firma Maxis veröffentlicht. Der wichtigste Mann im Entwicklungsteam war ein gewisser Will Wright. Er war der Hauptinitiator der Idee, mit Simulationen unterhaltsame Spiele zu bauen. Er ist auch der Erfinder der Sims, bei denen man wie in einem Puppenhaus Familie spielen kann. Es gilt als das erfolgreichste Computerspiel überhaupt und wird auch sehr viel von weiblichen Computer-Enthusiasten gespielt. Das Spiel wurde zuerst für den C64, später auch für Amiga, Atari ST, den PC und den Mac herausgebracht. Inzwischen ist es auch für neuere Spielkonsolen verfügbar. 1997 wurde die erfolgreiche Softwareschmiede für Simulationsspiele von der Firma Electronic Art übernommen. Diese Firma war bis 2008 der größte Computerspiele-Hersteller der Welt. Will Wright verließ das Unternehmen im April 2009 und arbeitet seitdem für seine eigene Firma Stupid Fun Club. SimCity hatte sehr viele Nachfolger (SimCity 2000, SimCity 3000, SimCity 4) und Weiterentwicklungen. Ob es nun darum ging, einen Vergnügungspark oder ein Eisenbahnunternehmen zu leiten, sie alle haben einen gemeinsamen Ahnen. Es gibt außerdem Weiterentwicklungen wie Tycoon City: New York, die weniger die Gestaltung als die Verwaltung einer Stadt simulieren und ebenfalls eine große Anhängerschaft gefunden haben (siehe Abbildung 9.17). Das Spiel LinCity finden Sie im Internet unter http://lincity.sourceforge.net/. Es ist für Windows, Linux und eine Reihe weiterer Systeme erhältlich, wie BeOS, OpenVMS, OS/2 und AtheOS. Nachdem man die gewünschte Datei aus dem Internet bezogen hat, kann man sie installieren. Zwei Versionen befinden sich auch auf der DVD unter Software zum Buch\Kap09\LinCity. Nach dem Start hat man die Auswahl zwischen 왘

Fortsetzen

왘

Neues Spiel

왘

Laden

왘

Speichern

왘

Einstellungen

373

9.3

9

Computerspiele

왘

Mitwirkende

왘

Beenden

Abbildung 9.17

Installationsroutine von Tycoon City: New York

Beginnt man ein neues Spiel, so darf man sich ein Szenario wählen: 왘

Szenario auswählen: 왘

Strand

왘

Schlechte Zeiten

왘

Trockengebiet

왘

Feuchtgebiet

왘

Gute Zeiten

왘

Mit leerem Feld beginnen

왘

Mit zufälligem Dorf beginnen

Möchte man ganz von vorn anfangen, wählt man natürlich Mit leerem Feld beginnen. In diesem Fall startet man mit 100 Obdachlosen in der Wildnis. Das Spiel gehorcht einem einfachen Prinzip: Wie im wirklichen Leben kommt es darauf an, nachhaltig zu wirtschaften. Bevor man größere Projekte in Angriff 374


nehmen kann, muss zunächst einmal für Nahrung, Wasser und Arbeit gesorgt sein. Es genügt jedoch nicht, vorausschauend zu wirtschaften, man sollte auch ständig die Parameter wie Bevölkerungszahl, Nahrungsversorgung und das technologische Niveau im Auge haben. Straßen zu bauen beispielsweise kann auf Dauer sehr teuer werden. Nicht nur, dass man zunächst planieren sollte – was übrigens wieder zuwächst, wenn man nicht schnell genug ist –, man sollte auch bedenken, dass Straßen anfangs nur dort erforderlich sind, wo Köhlereien stehen. Wenn man baut, kostet das Geld, und Geld kostet Zinsen. Abbildung 9.18 zeigt ein einfaches Dorf mit einem Brunnen, einem Markt, zwei Bauernhöfen, zwei Köhlereien und einer Siedlung für 50 Personen sowie zwei Baustellen für Monumente. Im nächsten Schritt sollte man Töpfereien anlegen, aber vor allem eine Barackensiedlung, damit die Bewohner Unterkunft finden.

Abbildung 9.18

Einfaches Dorf in LinCity

Direkt nach einer Dorfgründung sollte man Monumente errichten, um den technischen Level zum Bauen von Schulen zu erreichen. Tut man das nicht, erreicht man nie das Niveau, um Mühlen und Elektrizitätswerke zu errichten. Brunnen sind unbedingt erforderlich, damit die Bevölkerung nicht verdurstet, Bauernhöfe versorgen die Märkte mit Agrarprodukten, die von der Bevölkerung gekauft werden können.

375

9.3

9

Computerspiele

Köhlereien erzeugen Holzkohle und in geringen Mengen Erz und Stahl. Erzbergwerke benötigen Strom und können ganz am Anfang nicht betrieben werden. Töpfereien produzieren Waren für den Eigengebrauch aber auch zum Verkauf über den Fernhandel. Hat man Brunnen oder Markt ausgewählt, zeigt ein großes Rechteck an, welche Umgebung von dem Objekt versorgt werden kann, sozusagen das Einzugsgebiet. Innerhalb eines Einzugsgebiets werden keine Straßen benötigt, nur für Gebäude, die außerhalb des Einzugsgebiets liegen braucht man Verkehrswege. Das gilt nicht für Köhlereien, die immer auf eine Straße angewiesen sind. Monumente benötigen recht lange, bis sie fertiggestellt sind. Sie versorgen dafür jedoch auch eine Menge Menschen mit Arbeit. In der ersten Phase ist es interessanter, Barackensiedlungen zu errichten, weil sie vielen Leuten Unterkunft bieten, ohne viel zu kosten. Die Sterblichkeitsrate ist jedoch in diesen Unterkünften sehr hoch. Sollte man Schwierigkeiten haben, die Siedlung in Schwung zu bekommen, so kann man natürlich auch mit einem anderen Szenario starten, etwa mit Gute Zeiten. Da fehlt dann nur noch Technologieniveau 75, um die ersten Raketenstarts durchführen zu können. Gewinnen im Sinne von zielorientierten Spielen kann man bei LinCity eigentlich nicht. Entweder wirtschaftet man erfolgreich, und dann endet das Spiel im eigentlichen Sinne nie, oder man hat einen so hohen Technologiestandard erreicht, dass man die gesamte Bevölkerung per Raumschiff auf einen anderen Planeten evakuiert. Hier endet das Spiel wirklich, denn es ist niemand mehr da, mit dem man weiterspielen könnte. Wahrsagerin: »Ob du das Spiel gewinnst oder nicht ist unwichtig. Die Hauptsache ist, dass du es gekauft hast.« – aus Vampire: The Masquerade – Bloodlines

9.4

Komm mit, ins Abenteuerland ...

9.4.1

Adventures

Ein weiteres frühes Spielgenre war das der Adventures, der Abenteuerspiele. Sie kamen von den mit Spielbrettern oder mit Notizblöcken gespielten Abenteuerspielen in den Computer. Das erste Spiel hatte jedoch eine ganz andere Entstehungsgeschichte. Ein Informatiker, William Crowther, der in seiner Freizeit Höhlensysteme erforschte, kam 1972 auf die Idee, seine Untersuchungen in der

376


Mammoth- und Flint-Ridge-Tropfsteinhöhle im US-Bundesstaat Kentucky interaktiv auf einem PDP-1-Computer zu verewigen. Darin konnte man mit Textbefehlen durch die Höhle wandern und sich an markanten Stellen Beschreibungen zur Höhle durchlesen. Don Woods, ein Student, der zufällig 1975 auf den Fortran-Quellcode dieses Programms stieß, verwandelte es mit Crowthers Hilfe in ein Spiel namens Adventure (Abenteuer), indem er die Höhlen mit Piraten, mit Schätzen, Zwergen und Labyrinthen ausschmückte. Die Existenz eines Textabenteuerspiels sprach sich rasch herum, und man kopierte das Spiel auf Bänder oder versandte es per ARPANET von Universität zu Universität. Das ist die nüchterne Version, Crowther selbst hat in einem Interview eine etwas phantasievollere Version ausgeplaudert: »Damals spielte ich in einem ›Ohne-Computer-Rollenspiel‹ namens Dungeons and Dragons mit, außerdem war ich begeisterter Höhlenforscher – speziell in der Mammut-Höhle in Kentucky, einer gewaltigen Höhle mit viel Geschichte. Wenn ich dort unten war, glaubte ich, Jules Verne müsse die Mammut gekannt haben, als er seinen Roman schrieb: ›Die Reise zum Mittelpunkt der Erde‹. In all diese Dinge war ich sehr eingebunden. Urplötzlich war ich außerdem in eine Scheidung eingebunden. Das brachte mich sehr aus dem Gleichgewicht. Vor allem vermisste ich meine Kinder. Außerdem hörte ich auf, in der Erde herumzukrabbeln. Um mir die Zeit zu vertreiben und dabei auf andere Gedanken zu kommen, begann ich, ein Computerprogramm zu schreiben. Es wurde so eine Art Rekonstruktion meines Höhlenforschens. Außerdem wollte ich, dass es etwas für Kinder werden würde, und dabei rutschten einige Aspekte von Dungeons und Dragons hinein, das ich früher gespielt hatte. Meine Idee war, dass es ein Computerspiel sein sollte, das den Computerlaien keine Angst einjagen durfte. Deshalb machte ich es so, dass der Spieler das Spiel mit Eingaben in natürlicher Sprache steuern konnte. Was auch meinen Kindern viel Spaß machte.« – Quelle: Genesis II: Creation and Recreation with Computers, Dale Peterson (1983). Die gesamte Geschichte und andere Details finden Sie unter http://www.rickadams.org/adventure/. Natürlich kann man dazu die verschiedensten spielbaren Versionen im Netz finden. Eine Seite mit zahlreichen Binarys ist: http://www.wurb.com/if/game/ 1 %20Adventure. Man kann es auch in deutscher Sprache spielen: http:// www.ifiction.org/games/play.phpz?cat=&game=235&mode=html.

377

9.4

9

Computerspiele

Eine kommerzielle Version gab es erst 1978 in abgewandelter Form als Spiel Adventureland für Homecomputer. Ein gewisser Scott Adams entwickelte dieses Spiel mit der extra dafür gegründeten Firma Adventure International. Später gab es sogar eine grafische Version des Textabenteuers. Eine erfolgreiche Weiterentwicklung von Adventureland bekam den martialischen Namen Zork. Erdacht haben sich dieses Spiel zwei MIT-Studenten, Marc Blank und Dave Lebling im Jahr 1977, und programmiert haben sie es in MDL3, einer 1971 am MIT entwickelten Sprache. Der etwas seltsame Name war ein Slangwort am MIT und stand für etwas namenloses, ein undefinierbares Etwas. Immer noch existierte kein Markt für Computerspiele, und Zork wurde auf die gleiche Weise verteilt wie Adventure. Da es reißenden Absatz fand, gründeten die Programmierer des Spiels nach ihrem Studium am 22. Juni 1979 die Firma Infocom. Sie portierten das Spiel für die verbreitetsten Heimcomputer. Weil es recht erfolgreich war, aber für Heimcomputer nicht vollständig auf einer Diskette realisiert werden konnte, gab es bald mehrere Teile, sozusagen Fortsetzungen des Originalspiels. Um diese Spiele nicht von Grund auf neu programmieren zu müssen, entwickelte man eine erste Spiele-Engine, die sogenannte Z-Machine, einen Interpreter für Textadventures. Praxis: Zork Auch Zork findet man heute natürlich im Internet. Man kann alle drei Teile dort auch im Original spielen, um die Faszination nachzuempfinden, die das Spiel damals auf die ersten Computerspiele-Freaks ausübte. Bis heute ist es nicht ganz von den Rechnern der Spielefans verschwunden. In vielen Artikeln der Fachzeitschriften wird es als eines der ersten Abenteuer-Computerspiele besprochen, wie beispielsweise hier: http://www.heise.de/tp/r4/artikel/9/9596/1.html. Durch den Einsatz der Z-Maschine bestehen diese Spiele aus vier Teilen. Aus der Z-Maschine, einem Interpreter, der Quelldatei zur Story, dem Compiler und dem kompilierten Spiel. Z-Machine-Interpreter für verschiedene Plattformen findet man auf dieser Seite: http://www.ifarchive.org/indexes/if-archiveXinfocomXinterpreters.html. Auf der DVD befinden sich ebenfalls zwei Beispiele für Interpreter: Software zum Buch\Kap09\ZMachine\BlorpleMachine.zip. In der gepackten Datei gibt es das Verzeichnis BlorpleMachine und darin die Datei ZMachine.exe. Es ist ein einfaches, in blau gehaltenes Programm, das auf allen Windows-Versionen laufen sollte. Zusätzlich gibt es auf der DVD einen Interpreter in Java mit 3 MDL = MIT Design Language

378


dem Quellcode und der ausführbaren Jar-Datei (Software zum Buch\Kap09\ ZMachine\zmpp-1.02-src.zip). In dieser gepackten Datei gibt es das Verzeichnis zmpp-1.02-src und darin die Datei zmapp-1.02.jar. Sie wird wie eine übliche JarDatei gestartet: java -jar zmpp-1.02.jar

Bei beiden Dateien wird zunächst eine Storydatei erwartet, das ist ein Z-Maschinen-Compilat, das meist die Endung .dat oder .z1 bis .z8 hat. Die entsprechende Datei befindet sich jeweils im gleichen Verzeichnis auf der DVD innerhalb der Zip-Dateien zork1 bis zork3, und zwar in dem Verzeichnis \Data. Diese Storydatei ist die zweite Datei, die zum Z-Maschine-System gehört. Es gibt noch einen Compiler, der aus der Quellstory dieses Compilat erstellen kann. Doch dazu später etwas mehr. Hat man die Storydatei ausgewählt, beginnt sogleich auch schon das Spiel. Man befindet sich vor einem Haus mit einem kleinen Briefkasten. Darin entdeckt man einen Zettel, auf dem der Begrüßungstext zum Spiel steht.

Abbildung 9.19

Zork I auf dem Java-Z-Machine-Interpreter

Der gleiche Java-Interpreter kann auch als Applet gestartet werden. Man kann ihn über eine Webseite direkt aufrufen und auf diese Weise Zork spielen, ohne

379

9.4

9

Computerspiele

es bei sich installieren zu müssen. Das Spiel finden Sie auf der Webseite: http:// zmpp.sourceforge.net/games/play.php?name=Zork%20I&storyfile=zork1.z3. So einfach ein solches Spiel anmuten mag, ganz so einfach ist es dann doch nicht zu erstellen. Deshalb möchte ich auch gar nicht näher darauf eingehen, zudem gibt es genug Informationen dazu im Web. Wer also selbst etwas für die ZMaschine schreiben will und die entsprechenden Tools sucht, wird hier fündig: http://www.inform-fiction.org/zmachine/ztools.html. Wichtig ist noch die Syntax der Quelldateien. Außerdem kann man Z-Maschinen noch zu einigem mehr bewegen, als nur dazu, Texte auszugeben. Es gibt moderne Erweiterungen, die auch Grafiken anzeigen können. Die entsprechenden Spezifikationen finden Sie unter http://www.gnelson.demon.co.uk/zspec/.

9.4.2

Rouge und Boulder Dash

Textadventures können prinzipiell auf jedem Rechner ausgeführt werden, ob Handy oder Cray-Supercomputer. Daher haben sie auch heute noch ihre Anhänger. Deshalb verwundert es nicht, dass noch 1996 eine Zork Spezial Edition herauskam, in der alle Zork-Teile, bis auf den Teil »Zork Grand Inquisitor«, zusammengefasst waren. Zork hat auch Spielegeschichte geschrieben, weil eine Fortran-Version des Spiels zum ersten Mal in der Spielegeschichte den Namen Dungeon (= Verlies) trug – ein Begriff, der bei den Entwicklern von Grafikadventures eine ausgesprochene Beliebtheit erringen sollte. Aus der ersten Form der Adventurespiele, die stets in unterirdischen Kavernen abliefen, entwickelte sich als Nebenlinie des Spielstammbaums die grafische Form der sogenannten Rogue-like-Spiele. Wie beim ersten Adventurespiel geht es dabei darum, sich in unterirdischen Höhlen und Verliesen zu orientieren und Schätze aller Art ausfindig zu machen sowie gegen Geister und Monster vorzugehen. Gemeinsam sind diesen Spielen Level oder Runden, die immer wieder neue Höhlenwelten präsentieren. Völlig vernachlässigt wird dabei meist, dass es in solchen Umgebungen eigentlich stockdunkel ist und man so eigentlich weder Gegner noch Schätze finden kann. Der Name der Spieleart stammt vom ersten Vertreter Rogue aus dem Jahr 1980. Das Spiel wurde von Glenn R. Wichman und Michael Toy programmiert, nachdem sie auf eine C-Bibliothek gestoßen waren, mit der man ASCII-Grafiken erzeugen konnte.

380


Aus dieser Spielform sind auch die »Boulder Dash«-artigen Spiele hervorgegangen. Die Spielfigur ist dabei meist ein Minenarbeiter oder ein Schatzsucher. Sie unterscheiden sich von den Original-Rogue-Spielen in der Art, wie die Spielfigur mit ihrer Umwelt agiert. Die unterirdischen Gänge sind nicht mehr nur statisch, Stücke brechen heraus und erschlagen die Spielfigur. Die Figur ist in der Lage, die Felsen bewusst zu manipulieren, da herabstürzende Objekte explodieren können und so Lücken in die Felswände reißen, die zu weiteren Kavernen führen. Außerdem sind die Gegner gefährlicher und müssen nicht selten überlistet werden. Die Boulder-Dash-Spiele bleiben dabei mit den Rogue-Spielen so weit verwandt, dass sie eigentlich eine Unterart dieser Spiele sind. Während bei den echten RogueSpielen die neuen Runden jedoch per Zufall generiert werden, sind die Spielwelten beim Boulder Dash in jedem Level statisch. Die schwierigere Spielsituation kann oft erst nach mehrmaligem Anlauf bewältigt werden, daher würden ständig wechselnde Welten dazu führen, dass man die Level nie schafft. Der Reiz beim Rogue-Spiel ist gerade die ständig unerwartet neue Spielumgebung und beim Boulder Dash die Erkundung und Erkenntnis der Schwierigkeiten in der Spielumgebung, die man durch Wiederholung schließlich überwindet. Damit waren die Möglichkeiten der Adventurespiele jedoch keineswegs ausgeschöpft. Sie sollten sich schließlich mit dem zweiten großen Genre, dem Rollenspiel, vereinen und dadurch ganz neue Ausprägungen finden. Die Arten der zweidimensional angelegten Abenteuerspiele sind damit jedoch ziemlich erschöpft. Wie es weitergehen sollte, hatte sich bereits im Jahr 1980 gezeigt. Während Rogue noch mit ASCII-Zeichen und Sonderzeichen auskommen musste, hatten Spiele wie Boulder Dash einfach eine Art mehrfarbige Zeichensätze oder Sprites, wie man frei bewegliche Figuren nannte, aus denen die Spielwelt bausteinartig zusammengesetzt wurde. Mystery House, ein grafisch untermaltes Textadventure aus dem Jahr 1980, besaß Liniengrafiken, die in der Art von Stiftzeichnungen das Spielgeschehen illustrierten. Das Spiel für den Apple II war von On-Line Systems angeboten worden. Programmiert hatte es der Informatiker Ken Williams, die Zeichnungen hatte seine Frau Roberta Williams beigesteuert. Wenn auch noch in zarten Anfängen, so zeigte sich doch schon deutlich, wo die Entwicklung hinführen würde: weg vom romanhaften Textspiel, hin zum filmischen Spielerlebnis.

381

9.4

9

Computerspiele

Praxis I: Boulder Dash Bolder-Dash-Spiele gibt es im Internet reichlich. In der Tat war es bereits in der Zeit des C64 eines der ersten großen Kultspiele. Um den Spielreiz zu erleben, sollte man unbedingt einmal selbst in die Haut von Rockford schlüpfen (so hieß der kleine Held im Original-Boulder-Dash für den C64) und sich unter Tage begeben, um Höhlen zum Einsturz zu bringen und Edelsteine zu schürfen. Man findet entsprechende Spiele auf der folgenden Homepage: http://www.gratisspiele-downloads.de/boulder-dash/, aber auch auf der DVD gibt es ein Exemplar, und zwar unter Software zum Buch\Kap09\BoulderDash\sub_inst.exe. Es handelt sich um das Spiel SubTerra für Windows-Rechner, das über 500 Level verfügt und einen Editor besitzt, um selbst Spielelevel zu erstellen. Es ist ein sehr phantasiereiches Spiel mit über 100 unterschiedlichen Objekten wie verschiedenen Edelsteinen, die es aufzusammeln gilt, und Bomben, die man geschickt nutzen muss, um verschlossene Gänge zu öffnen. Bewegt wird Rockford mit den Cursortasten. Um zu graben, drückt man zusätzlich die (ª)-Taste. Außerdem kann man damit Felsen verschieben. In manchen Leveln lassen sich Dynamitstangen einsammeln, die sich mit Hilfe der (Strg)Taste zünden lassen. Mit der (P)-Taste kann man das Spiel anhalten und mit der Leertaste weiterspielen. Pausiert das Spiel, lässt sich mit den Cursortasten die Spielfläche hin- und herschieben, damit man sich orientieren kann.

Abbildung 9.20

382

SubTerra, eine Boulder-Dash-Version (Rockfort steht in der Bildmitte.)


Praxis II: Eigene Level entwerfen Nachdem man einige Spiele gespielt und Routine in der Technik dieser Spielart gewonnen hat, kann man beginnen, eigene Level zu entwerfen. Am sinnvollsten dabei ist, das Labyrinth auf einem Blatt Papier zu skizzieren. Schon allein deshalb, weil es erheblich größer werden darf als der Bildschirm. Starten Sie das Programm, und rufen Sie nach der Auswahl des Spielers den Menüpunkt Edit Levels auf. Der Editor besteht aus einem leeren Spielfeld und den Bauelementen rechts daneben. Zunächst einmal sieht man nur die Wände (walls). Klickt man die Schrift an, kann man wechseln zwischen 왘

Walls

왘

Falling objects

왘

Boxes & Tools

왘

Enemis

Hat man sein raffiniertes Labyrinth zusammengestellt, kann man es testen (siehe Abbildung 9.21). Dazu dient der Pfeil im Icon-Feld unter den Bauelementen. Wie üblich, beginnt man das Spiel mit der Leertaste.

Abbildung 9.21

Labyrinth Marke Eigenbau

383

9.4

Computerspiele

9.4.3

Eine Schlange geht nach Hollywood

Was mit der ersten einfachen Grafik aufkam, waren Geschicklichkeitsspiele. Eines der ersten hat es gar bis nach Hollywood geschafft. Ursprünglich hieß es Snake (= Schlange). Darin bewegt der Spieler einen unsichtbaren Pinsel über den Bildschirm. Dieser zieht eine Linie hinter sich her, die er nicht mehr berühren darf. Hindernisse und ein Gegner mit der gleichen Schlange erschweren die Sache. Der Platz auf dem Schirm wird natürlich immer enger, bis es zum Crash kommt und damit der Verlierer feststeht. Mauern, die ein virtuelles Motorrad hinter sich herzieht, sieht man in dem ersten computeranimierten Spielfilm Tron, und daher erhielt dieses Spiel auch seinen zweiten Namen. Disney hat sich entschlossen, diesem Computer-Filmklassiker einen zweiten Teil als 3D-Film folgen zu lassen. Er trägt den Titel »TRON Legacy«. Einen Trailer zu diesem Film kann man sich auf der Webseite http://disney.go.com/tron/#/movie ansehen.

Quelle: http://gl-tron-saver.softonic.de/mac

9

Abbildung 9.22

Das legendäre Todesrennen im Hollywoodstreifen »Tron«

In den Jahren der Homecomputer wurde aus Computerspielen ein Milliardenmarkt, und die Spielideen schienen in den Himmel zu wachsen.

9.4.4

Rollenspiele

Wer die Geschichte der Rollenspiele betrachtet, kommt an Dungeons und Dragons nicht vorbei. Die Geschichte dieses Spiels fand jedoch zum größten Teil unabhängig vom Computer statt. Das sehr erfolgreiche Brettspiel beeinflusste die Entwicklung von Rollenspielen für den Computer so stark, dass man bei genauem Hinsehen eigentlich nur Variationen der D&D-Spielidee – so kürzt man den langen Spielnamen ab – vorfindet. D&D selbst wirkt wie eine weitere Aus-

384


prägung der Idee von William Crowthers Höhlenbesichtigungsprogramm, obwohl es früher entstand. Alles begann 1965 in Lake Geneva mit der Gründung des Clubs Tactical Studies Association. Der Gründer Gary Gygax untersuchte dort mit seinen Kollegen Konfliksituationen und deren Bewältigung. 1972 stieß er auf die Pläne des strategischen Rollenspiels Twin City Wargame, die ein gewisser Dave Arneson gezeichnet hatte. Das mittelalterliche Flair dieser Ideen brachte Gygax dazu, daraus Spielregeln für ein sogenanntes Tabletop-Spiel (Brettspiel) zu entwickeln. Die zweite Version dieses Spiels nannte er Dungeons & Dragons und begann 1974 den Vertrieb über den eigens dafür gegründeten Verlag Tactical Studies Rules (TSR). Die Namen verraten bereits, dass es dabei eigentlich nicht um reine Rollenspiele, sondern um eine Verbindung aus Rollen- und Strategiespiel geht. Über einen Kontakt in England kam das Spiel nach Europa, wo es ebenfalls mit viel Erfolg verkauft wurde. Die erste Übertragung dieses Spiels auf den Computer war DnD, das bereits 1974 programmiert wurde, also im gleichen Jahr, in dem D&D in die Läden kam.

© Moroboshi; http://commons.wikimedia.org/

Zur Unterscheidung zwischen dem Brettspiel und den Softwarespielen verwendet man auch oft den Begriff Pen-&-Paper-Rollenspiel (PPR) als Gegenpart zu RPG (computer role-playing game).

Abbildung 9.23

Dungeons and Dragens als Pen-&-Paper-Rollenspiel

Bereits in der Ära der Großrechner gab es eine ganze Reihe von Rollenspielen, die von Studenten programmiert wurden. Sie waren fast ausschließlich Produkte der Faszination, die von D&D ausging. Wie bei den anderen Spielformen begann

385

9.4

9

Computerspiele

auch hier der echte Boom mit der weiten Verbreitung der Homecomputer. Die Wandlungen und Verbesserungen sind so zahlreich, dass man sie im Rahmen eines Buches nicht alle besprechen kann. Deshalb sind im Folgenden nur die wichtigsten Entwicklungen stichpunkartig betrachtet. Raycasting Um eine 3D-Welt halbwegs real aussehen zu lassen, muss man den Weg der Sehstrahlen berechnen. Ein solcher Strahl tritt aus dem Auge des fiktiven Betrachters und bewegt sich durch den Raum, bis er auf die Oberfläche eines Gegenstandes trifft. Dort erzeugt er einen Farbpunkt oder eine Farbfläche, je nachdem, wie hochauflösend das darzustellende Bild werden soll. Der Sehstrahl bestimmt also das Aussehen der virtuellen Welt, abhängig vom Standpunkt des Betrachters. Bei Spielen kommt hinzu, dass diese Berechnung und die daraus resultierende Darstellung so rasch ablaufen muss, dass bei Bewegungen ein halbwegs fließender Ablauf sichtbar wird. Bei den frühen Grafikkarten war dies schlichtweg unmöglich. Aus diesem Grund sandte man die Sehstrahlen nicht durch den virtuellen Raum, sondern nur über eine einzige Fläche in diesem Raum. Gerade so, wie man eine Torte mit einem Faden waagerecht durchschneidet. Was jedoch bedeutete, dass die Objekte von oben bis unten gleich aussehen mussten, weil ihre Höhe unberücksichtigt blieb. Da hatte zur Folge, dass der virtuelle Raum immer nur aus senkrecht stehenden Flächen bestand, zwischen einem Boden und der Decke. Um Schrägen oder Rundungen halbwegs erkennbar zu machen, verwendete man statt des Shadings der Oberflächen entsprechend eingetönte und schräg oder gebogen aussehende Texturen. Noch aufwendiger wurde die Darstellung von sich bewegenden Objekten, wie den Avataren innerhalb des Spiels. Da ihr Aussehen schon mal gar nicht gerendert werden konnte, wurden sie als fertig gerenderte Bildchen vom Datenträger in das Bild der Umgebung einkopiert, je nachdem, in welchem Winkel man sie betrachtete. Diese Technik nennt man Raycasting. Einige der Spiele, die mit dieser Technik erstellt wurden, sind: Doom, Catacomb, Wolfenstein 3D und Duke Nukem 3D. Ebenfalls eingesetzt wurde diese Technik beim 3D-Labyrinth-Screensaver von Windows 95. Entwicklung der Rollenspiele 1985 kamen mit Bard's Tale erstmals mehrfarbige Grafiken mit erkennbarem Charakter und Landschaften ins Spiel. 1987 verfügte Dungeon Master über erste Echtzeitelemente und die Möglichkeit, Gegenstände aus der Umgebung mit ins Spiel einzubeziehen.

386


1988 kann Pools of Radiance erkennbare Kämpfe in Draufsicht darstellen. 1991 wurde mit Neverwinter Nights das erste echte MMORPG auf den Markt gebracht. 1992 läutete Ultima Underworld I eine gewaltige Revolution in der Spielewelt ein. Dieses Spiel hatte erstmals mit Raytracing berechnete echte 3D-Grafik im Gegensatz zur Raycasting-Technik der Vorgänger. Um die Rechenleistung bewältigen zu können, zeigte man die 3D-Welt einfach in einem kleinen Ausschnitt innerhalb des Spieledialogs. Je nach Rechenleistung ließ sich dieses Bild vergrößern. Diese Technik der verkleinerten Darstellung wurde danach zu einem Standard bei den 3D-Spielen. 1996 begann sich die kommende Revolution zu einem Action-RPG-Boom auszuweiten. Der Initiator der Entwicklung nannte sich Diablo. In diesem finsteren, der D&D-Welt treu gebliebenen Abenteuer konnte der Spieler durch eigene Aktionen den gesamten Ablauf des Spiels beeinflussen. 1998 kam mit Baldur's Gate eine weitere Spielform hinzu, das sogenannte Storytelling-RPG, das mehrere völlig verschiedene Spielverläufe möglich machte. In Baldur's Gate ist es dem Spieler überlassen, ob er sich zu einer guten oder bösen Hauptfigur weiterentwickelt. Eine grafische Aufwertung, aber spielerische Abwertung erfuhr das Rollenspiel im 3D-Egoshooter. Ein Teil der betrachteten Spiele sind direkte Vorgänger oder bereits Vertreter dieser Spielform. Raytracing Wie bei der Betrachtung des Raycastings bereits angedeutet, ist Raytracing ein Verfahren zur wirklichkeitsnahen 3D-Darstellung. Es wurde im Bereich des CAD entwickelt und schaffte es durch die enorme Leistungssteigerung der PC-Grafikkarten bis zum Echtzeitrendering bei den 3D-Spielen. Beim Raytracing betrachtet man im Gegensatz zum Raycasting die Blickstrahlen räumlich. Eine Optimierung kann man erreichen, indem man Strahlen, die ins Unendliche laufen, und Flächen, die vollständig durch andere Flächen verdeckt werden, von vornherein ausschließt. Außerdem kann man das darzustellende Bild in gleichgroße Quadrate aufteilen und für den Strahl nur die Teilflächen der Objekte berücksichtigen, die innerhalb des aktuell durchkreuzten Quadrates liegen. Verbesserungen erfuhr das Raytracing mit dem sogenannten MLT- und PhongShading sowie dem Photon Mapping. Bei Letzterem werden nicht nur die Sehstrahlen berechnet, sondern auch die Strahlen der gesetzten Lichtquellen. Die

387

9.4

9

Computerspiele

ersten Programme, die das volle Raytracing im Egoshooter-Bereich einsetzten, waren Descent und Quake. Egoshooter Diese Spielform entstand durch eine ständige Verbesserung der 3D-Darstellungsmöglichkeiten. Beim Egoshooter wird nicht nur die virtuelle Umwelt des Spielers in Echtzeit gerendert, sondern auch der Spieler selbst. Das heißt, wenn sich der Egoshooter-Spielende vor einen Spiegel stellt, wird er seinen Avatar sehen und die von ihm gesteuerten Bewegungen. Egoshooter sind außerdem meist recht einfach gestrickte Ballerspiele. Warum das so sein muss, ist nicht ganz klar. Jedoch hat der hohe Aufwand an Grafik aus Kostengründen meist eine einfachere Handlung bedingt. Egoshooter lassen sich aber auch schwieriger mit szenischen Handlungssträngen hinterlegen, weil der Spieler im wahrsten Sinne des Worts eigentlich tun kann, was er will. Dennoch stellen Egoshooter aktuell den höchsten Stand der Entwicklung dar. »Mein Anführer, wir haben die Pyramiden festgenommen!« – aus Civilisation 2

Abbildung 9.24

Intro des Spiels Quake III Arena

Zu den Egoshootern zählen Spiele wie der Bestseller Doom, Quake (beide Spiele stehen in Deutschland auf dem Index), Unreal oder Half-Life.

388

Die größten Meilensteine in der Computerspiel-Geschichte

9.5


9.5.1

MobyGames

Das Internet würde seinem Ruf nicht gerecht werden, wenn es dort kein Archiv für Computerspiele gäbe. Diese universelle Übersicht über Spiele für den Computer aller möglichen Betriebssysteme und Konsolen nennt sich MobyGames. Die Betreiber haben sich die Aufgabe gestellt, alle historischen und aktuellen Computerspiele zu erfassen. Aktuell sind etwa 50.000 Spiele erfasst und mit fast 400.000 Screenshots dokumentiert. Jede Spielversion, auch die für andere Rechner und Betriebssysteme, ist separat erfasst und dokumentiert. Die Webseite von MobyGames ist http://www.mobygames.com/home. Ebenfalls eine interessante Webseite ist die iFiction-Seite von Dave Walton. Er hat hier sehr alte Computerspiele zusammengetragen, die für die Geschichte der Computergames von großer Bedeutung sind (http://www.ifiction.org/). Experiment und Forschung Jahr

Name

1952

OXO

1958

Tennis for Two

1962

Spacewar

1975

Adventure

1977

Zork

Kommerzielles Einzelspielergame Jahr

Name

1972

Pong

1976

Breakout, Night Driver

1978

Space Invaders, Adventureland

1979

Snake (Tron)

1980

Rogue, Ultima, Pac-Man, Mystery House, Defender, Red Baron

1980

Space Panic, Battlezone

1981

Castle Wolfenstein, Donkey Kong

1982

Pole Position, Zaxxon, Q-Bert, Midnight Magic (Pinball), Sokoban

1983

Dragon’s Lair, Ant Attack, MULE

389

9.5

9

Computerspiele

Jahr

Name

1984

Kings Quest, Elite, Boulder Dash

1985

Super-Mario, Tetris, Little Computer People, Gauntlet

1986

Winter Games

1987

Maniac Mansion, Dungeon Master, Street Fighter

1988

Battle Chess

1989

Prince of Persia, Populous, SimCity

1990

Wing Commander, Loom

1991

Civilization, Lemmings, Space Quest

1992

Dune II, Wolfenstein 3D, Alone in the Dark

1993

Die Siedler

1994

Cyberia, Warcraft

1995

Command & Conquer, Albion

1996

Quake, Tomb Raider, Pokémon

1997

Diablo

1998

Metal Gear Solid, Baldurs Gate, Anno 1602

2000

Die Sims

2001

Gothic

Kommerzielles Online- und Massenspiel Jahr

Name

1993

Doom

1994

Panzer General

1995

Command & Conquer, Albion

1996

Tomb Raider, Pokémon

1997

Diablo

1998

Metal Gear Solid, Dark Project, Unreal

2000

Die Sims

2001

GTA III, Black & White

2005

World of Warcraft

2009

EVE Online

390


Merchandising-Spiele Jahr

Name

1992

Star Wars (X-Wings)

1993

Indiana Jones

1997

Star Trek (Generations)

1999

Moorhuhn

2001

Harry Potter (Der Stein der Weisen)

2003

Jurassic Park

Diese Spiele kamen auf den Markt, um mit bestehenden Marken noch mehr Geld zu verdienen. Obwohl eine ganze Reihe von Spielen selbst MerchandisingErfolge aufstellen konnten, was nicht selten bis zur Verfilmung reichte. Populärstes Beispiel ist Tomb Raider mit der Spielfigur Lara Croft. So bezieht sich die Liste der Merchandising-Spiele auf Computerspiele, die als Merchandising-Element als Zugabe zu Filmen, Büchern oder anderen Produkten entwickelt wurden. Das erfolgreichste deutsche Spiel in dieser Reihe ist unangefochten Moorhuhn.

9.5.2

Von Partys, Money, Modding, MOG und MMOGs

Die Unterscheidung zwischen Einzelspielergames und Multiuserspielen ist nicht immer eindeutig, da viele Einzelspielergames schon sehr früh spezielle Modi hatten, mit denen der Computer durch einen zweiten Mitspieler ersetzt werden konnte. Die beiden Spieler nutzen dabei teilweise sogar einen gemeinsamen Monitor. Das änderte sich, als Modems aufkamen, um Mailboxen anzuwählen. Mit der gleichen Technik wurde es auch möglich, mit einem räumlich entfernten Spieler gemeinsam ein Spiel zu spielen. Die ersten richtigen Mehrbenutzerspiele entstanden. Konnte man vorher über Verbindungen mit seriellem oder parallelem Kabel mit zwei Rechnern zu zweit spielen – was übrigens ganz selten von Spielesoftware unterstützt wurde –, so war es nun theoretisch möglich, mit beliebig vielen Spielern zu spielen. Als der Privatnutzer begann, sich Zweit- und Drittrechner zuzulegen und Netzwerke im Privathaushalt zu installieren, entdeckten die Spielehersteller den Bedarf an Multiusergames. Plötzlich konnte man seinem Freund, der zwei Meter neben einem saß, im Cyberspace begegnen (Doom – bis zu drei Spieler, Quake, Unreal).

391

9.5

9

Computerspiele

Abbildung 9.25

Homepage von WoW mit verstecktem Abohinweis

Um vor und in den Anfangszeiten des Internets diese Spiele gemeinsam spielen zu können, kam man auf die Idee, große Räumlichkeiten zu mieten und sogenannte Lanpartys zu veranstalten (siehe Abbildung 9.26). Rechner wurden angeschleppt und in stundenlanger Arbeit mit ganzen Kaskaden von Switches (Englisch für Weiche) verstöpselt. Damit entstand das Bedürfnis, einen schöneren Rechner als der Nachbar auf den Tisch stellen zu können – das Modding (Englisch für Umbau) war erfunden. Heute verwendet man eher den Begriff Case Modding. Diese Mode dürfte allerdings mit dem Seltenerwerden von Lanpartys auch untergehen. Das Bedürfnis, die virtuelle Wirklichkeit zu bevölkern, weitete sich rasch aus. MMOGs wurden entwickelt, Spiele, die riesige virtuelle Welten auf den Servern realisierten und es so theoretisch Millionen Menschen möglich machten, an einem einzigen Spiel teilzunehmen. Marktführer ist eindeutig WoW, World of Warcraft (siehe Abbildung 9.25). Aber inzwischen machen sich immer mehr sogenannte Browser MMOGs daran, dem König den Thron zumindest einmal anzusägen. Einen Vorteil haben sie dabei in der Regel: Sie sind kostenlos, zumindest im Moment noch und in der billigsten Version.

392

© Toffelginkgo; http://de.wikipedia.org


Abbildung 9.26

Die Dreamhack-Lanparty von 2004

Mit den MMOGs kamen auch die Dauerüberweisungen aus dem Kinderzimmer. Der Filius musste dem Ernährer der Familie erklären, warum jeden Monat etwas zu überweisen ist, damit er weiter stundenlang daddeln kann. Waren die Noten entsprechend schlecht, gab's damit bestimmt ein Problem. Dabei waren gute Spiele noch nie billig, und über die Spiele hinaus entstanden manchmal eine ganze Menge Zusatzkosten. Der Begriff Merchandising wurde bereits erwähnt. Frage: »Soldat, Sie wollen alleine gegen die gesamte Mannschaft kämpfen?!« Antwort: »Klingt unfair ... vielleicht sollte ich mit links schießen ...« – aus Command & Conquer: Renegade

9.5.3

Sonderformen

Geschicklichkeitsspiele Geschicklichkeitsspiele haben, wenn man es ganz genau nimmt, auf dem Computer eine weite Verbreitung gefunden. Die Steuerung von grafischen Objekten über den Bildschirm mit den doch ziemlich einschränkenden Bediengeräten Tastatur, Joystick und Maus legt die Entwicklung von Geschicklichkeitsspielen sehr nahe. Im Grunde ist jedes Ballerspiel eine Art Geschicklichkeitsspiel. Aber auch Spiele wie Kong und Super-Mario gewinnen ihren Spielreiz aus Situationen, die mit der Geschicklichkeit des Spielers zusammenhängen.

393

9.5

9

Computerspiele

Neben dieser Art von Geschicklichkeitsspielen kann man seit der jüngeren Vergangenheit auch viele Spiele der Wii-Konsole zu den echten Geschicklichkeitsspielen zählen. Die Besonderheit der Controller, die Bewegungen im 3D-Raum vermessen können, erfordert entsprechende Übung und fördert die manuelle Geschicklichkeit in noch stärkerem Maße als die alten Spiele, bei denen es oft nur darauf ankam, möglichst schnell eine bestimmte Taste zu betätigen. Lege- und Verschiebespiele Eine in der realen Welt doch recht verbreitete Spielform sind die Lege- und Verschiebespiele. Ganze Generationen haben sich von Anbeginn der Menschheitsgeschichte damit schon die Zeit vertrieben. Selbst den Zauberwürfel Rubik's Cube kann man im Grunde in dieser Nische ansiedeln. Es gibt berühmte ältere Beispiele. Tangram, ein chinesisches Spiel aus dem 8. Jahrhundert v, Chr., soll von Napoleon Bonaparte in der Verbannung gespielt worden sein (zumindest schreibt man über ihn, er habe es versucht). Das Legespiel besteht aus sieben Steinen, worunter es zwei Pärchen gibt. Die Steine sind so gewählt, dass man mit viel Phantasie Tausende von Figuren damit legen kann. Zur Erfindung des Spiels gibt es eine schöne Legende, die ich meinen Lesern nicht vorenthalten möchte: »Ein buddhistischer Mönch reichte eines Tages seinem Lieblingsschüler, einem begnadeten Maler, eine Schiefertafel und gab ihm den Auftrag, eine Pilgerfahrt durch die ganze Welt anzutreten, um auf der Tafel alle denkwürdigen Gestalten, die er finden würde, zu zeichnen. Der Schüler brach auf und kam zum nächsten Tempel, den er so schön fand, dass er ihn zeichnen wollte. Doch er musste feststellen, dass er auf seiner Reise die Kreide, die er sich eingesteckt hatte, verloren hatte. Er eilte zur Klause der Mönche, um Kreide zu erbitten, stolperte dabei, die Tafel fiel zu Boden und zersprang. Es waren genau sieben Teile. Nachdem er wieder Kreide besaß, versuchte er die Tafel zum ursprünglichen Rechteck zusammenzufügen, um den Tempel zu zeichnen. Aber solange er es auch versuchte, es wollte ihm nicht gelingen. Stattdessen fand er über seinen Versuchen ein Muster, das genau aussah wie der Tempel, den er zeichnen wollte, aber auch viele andere Dinge, die er kannte, aber auch welche, die er noch nie gesehen hatte. So kehrte er glücklich zu seinem Meister zurück und zeigte ihm mit einer einzigen Schiefertafel alle Wunder der Welt.«

394


Praxis I: Tangram Genau diese Wunder der Welt wollen wir uns einmal am Computer ansehen. Auch von diesem uralten Spiel gibt es inzwischen die verschiedensten Versionen für den PC. Eine dieser Tangram-Versionen finden Sie auf dieser Webseite: http:// www.pcfreunde.de/download/l2717/crazy-tangram/, aber auch als WindowsVersion gibt es sie auf der DVD zum Buch unter Software zum Buch\Kap09\Tangram\ctan2.exe. Die exe-Datei läuft unter den üblichen Windows-Versionen und besitzt eine Setup-Routine, mit der man sie z. B. auf einem virtuellen System auf einfache Weise installieren kann. Wenn man sie startet, bekommt man zunächst in einem kleinen Dialog eine Figur zu sehen, die es zu legen gilt. Auf dem großen Dialogfeld liegen die einzelnen Steine, die sogenannten Tans, am Rand verteilt. Nun kommt es zunächst einmal darauf an zu erkennen, an welche Stelle die jeweiligen Steine gehören, damit man genau die gezeigte Figur hinbekommt. Bewegen lassen sich die Teile durch Anklicken und Ziehen mit der Maus. Klickt man in die Ecke, erwacht eine Rotationsfunktion, mit der man den Baustein drehen kann. Die Icon-Leiste unter dem Dialogkopf bietet folgende Funktionen: 왘

Neues Spiel

왘

Laden

왘

Speichern

왘

Ton an/aus

왘

Statistik

왘

Musterübersicht

왘

Hilfestellung

왘

Nächstes Muster

왘

Voriges Muster

왘

Beenden

왘

Sprachwahl

왘

Info und Anleitung

왘

Lizenzhinweis

Es existiert die Geschichte, Napoleon habe das Spiel in der Verbannung auf St. Helena gespielt. Er habe es nicht beherrscht und es sei deshalb öfter vom

395

9.5

9

Computerspiele

Tisch aus durchs Zimmer geflogen ... Natürlich war es damals noch keine Computerversion. Jetzt haben Sie die Chance zu versuchen, ob Sie es besser können als der große kleine Korse.

Abbildung 9.27

Tangram-Spiel

Weitere Legespiele Neben dem Tangram gibt es eine europäische Version des Legespiels, das von den Griechen stammt und Archimedes zugeschrieben wird. Wahrscheinlich ist es jedoch älter und wurde von Archimedes in seinen Schriften nur besprochen (http://de.wikipedia.org/wiki/Ostomachion). Für solche Spiele hat das englische Wort »Puzzle« eine vorherrschende Rolle bekommen. Spiele dieser Art entstammen zum größten Teil der vorelektronischen Zeit, haben jedoch in verschiedenen Implementierungen vereinzelt ihren Weg auf den Computermonitor gefunden. Es gibt jedoch ein Computerspiel, das in diesem Bereich alle anderen geschlagen hat. Es heißt Sokoban und wurde bereits 1982 von dem Japaner Hiroyuki Imabayashi erfunden und für verschiedene Computersysteme programmiert und vertrieben. Der Spieler hat im Spiel als Lagerarbeiter im Hafen den Auftrag, eine oder mehrere Kisten zu bestimmten Plätzen zu transportieren. Das Problem ist dabei, dass er sich in begrenzten Räumen bewegt, in denen ihm jede abgestellte Kiste den 396


Rückweg versperren kann. Es gibt immer mehrere Level, deren Schwierigkeitsgrad stark variieren kann. Man kann sich das nur bedingt vorstellen, wenn man es aber einmal gespielt hat, weiß man gleich, worum es geht. Praxis II: Sokoban, der intelligente Kuli Das Interessante an dem Spiel Sokoban ist die Möglichkeit, die Spielanforderung variabel erhöhen zu können. Aus diesem Grund wird hier einmal eine schwierigere Version von Norman Krebs vorgestellt, damit die Rätselknacker unter den Lesern auch einmal auf ihre Kosten kommen. Das Programm finden Sie auf der DVD unter Software zum Buch\Kap09\Sokoban\Sokoban2SetupB.exe. Diese Installations-Datei für Windows enthält die lauffähige Version und den Quellcode in Delphi 7. Sie können wählen, was installiert werden soll. Nach der Installation können Sie das Spiel über das Windows-Menü starten, indem Sie unter Kohns Sokoban 2 die Datei Sokoban 2 anklicken.

Abbildung 9.28

Einfaches Sokoban

Das Spielprinzip ist sehr einfach. Die Rubine müssen auf die grünen Augen geschoben werden. Hat man alle Rubine untergebracht, hat man den aktuellen Level bestanden und kann sich am nächsthöheren Level versuchen (siehe Abbildung 9.28). Die verschiedenen Räume kann man übers Menü und über den Menüpunkt Rooms auswählen. Wenn man das Spiel noch nicht kennt, wird man zunächst etwas Probleme damit haben. Man neigt dazu, kurze Wege zu gehen und die Steine in Ecken zu schie397

9.5

9

Computerspiele

ben, aus denen man sie nicht mehr herausbekommt. Wichtig ist, dass man die Steine auf möglichst frei erreichbare Stellen schiebt, solange sie ihr Ziel nicht erreicht haben. Bei vielen Räumen gibt es Rollbahn genannte Strecken, auf die man die Steine nach und nach schiebt und zum Ziel rangiert. Aber selbst dort muss man noch aufpassen. Die Zielreihen füllen sich, und man verbaut sich unter Umständen so den Weg für die letzten Steine. Daher immer zuerst überlegen. Mit der (Esc)-Taste kann man den aktuellen Raum wieder in den Startzustand zurückbringen. Versuchen Sie sich erst an dem Raum namens easy, bevor Sie zu extra wechseln. Wenn Sie alle Räume gemeistert haben oder Ihnen die Beispiele viel zu einfach vorkommen, bauen Sie sich doch einfach eigene Lagerhallen zusammen. Dazu wechseln Sie in das Verzeichnis Sokoban2/rooms, in dem sich die Dateien befinden, die den Aufbau der Räume beschreiben. Es sind einfache Textdateien: 왘

@ stellt Mister Sokoban dar.

왘

# steht für einen Mauerstein.

왘

. ist ein grünes Auge.

왘

$ ist ein Rubin.

왘

+ ist Mister Sokoban auf einem Auge stehend.

Zuerst erarbeitet man sich eine Lagerhalle oder ein Labyrinth, das man für akzeptabel hält. Dabei kennzeichnet man die einzelnen Level nicht. Das Programm trennt die geschlossenen Räume automatisch in Level auf und nummeriert sie fortlaufend durch. Kommentare lassen sich hinter einem Strichpunkt einfügen. ;Goddy Level 1 ##################### # ###### # # #### ## # # #### ## # ## ### # # ## ### # ######## # # # # ## # # # # ## # # ## ### ## # ## # ## ### # # # # # # ### # # # # ####### # ## # # # ## # # # # # ## # # # # # ## ### # ##################### -end-

398


Danach sucht man sich die Stellen, an denen man die grünen Zielpunkte positioniert. Das kann natürlich nur vorläufig sein, weil sich die endgültige Form nur durch ständiges Probieren ermitteln lässt. ;Goddy Level 1 ##################### # @#####... # # $ #.## ... # # $ #... .#. .##.# ## ### #. ... .##.# ## ### ## #### #### # # # ## ## # # # ## #. # ## ### ## # ##. # ## ### #### # ##. # # ### ## ##. # # ####### ### ##. # # # ## #### #. # # # ## # #. #. # # ## ###. # ##################### -end-

Ein spielbare Lösung finden Sie auf der DVD unter Software zum Buch\Kap09\ Sokoban\Lösung\Fun. Kopieren Sie die Datei in das Verzeichnis Sokoban2/rooms, und wählen Sie es über das Menü mit Rooms 폷 Fun aus.

Abbildung 9.29

Fun Sokoban

399

9.5

9

Computerspiele

»What is your name?« »My name is Guybrush Threepwood!« »Haha, that's the stupidest name I've ever heard!« »What's your name?« »Manlecomb Sleeppelstreep.« – aus Monkey Island Bewegungs-/Sportspiele Nintendo hat 2005 den Vorwurf der Gesundheitsschädlichkeit von Computerspielen zum Anlass genommen, die neue Videokonsole mit speziellen lagesensiblen Controllern auszustatten. Dadurch entstand die Möglichkeit, die Bewegungen des Spielers zu erfassen und auf diese Weise Spiele zu steuern. Die Wii-Konsole, die im November 2006 auf den Markt kam, wurde damit zu einem der erfolgreichsten Spielgeräte überhaupt. Statt mit dem Joystick ruhig auf dem Sofa zu sitzen und auf den Fernseher zu stieren, hampelt der Wii-Spieler nun gesundheitsförderlich auf dem Wohnzimmerteppich herum. Bleibt abzuwarten, wann es entsprechende Eingabecontroller für PC-Spiele gibt und wann man entsprechende Statistiken zur Gesundheit der Wii-Videospieler veröffentlicht.

9.6

Spielerwelt in Spielersprache

Da die MMOGs gezwungenermaßen aufgrund der Gruppenbildung innerhalb der teilnehmenden Spieler und auch ohnehin aufgrund der Mehrspielertauglichkeit Verständigung erfordern, hat sich mit ihnen die Bildung einer speziellen Spielersprache, des Gamerslangs, noch verstärkt. Ein Außenstehender hat kaum noch eine Chance, hier irgendetwas zu verstehen. Aus diesem Grund folgt nun ein kurzer Einblick in diese Sprache, wo man bei Bedarf nachschlagen kann. 왘

AE, AoE: (Area of Effect) Abkürzung für den Wirkungsbereich. Wenn also eine Magie oder ein Angriff nicht nur ein einzelnes Ziel trifft, sondern eine bestimmte Fläche, spricht man von AE.

왘

AFK: (Away from Keyboard) Das Gegenüber hat den Rechner zwar noch an, ist jedoch kurz weg. Es gibt verschiedene andere Abkürzungen für diesen Sachverhalt – bis hin zu PP = Pinkelpause.

왘

Aggro: (Angriffswelle) Einen Mob, der von sich aus angreift, nennt man so, aber auch den Angriff selbst. Die meisten Mobs verfallen in den Aggro-Status, sobald man sie angreift.

400


왘

Bankchar: Wird ein Charakter dazu benutzt, Gegenstände zu parken, nennt man ihn Bankchar oder Mule (Esel).

왘

brb: (be right back) Ein Spieler ist kurz abwesend.

왘

Buff: Verstärkt man eine Eigenschaft mit Hilfe eines Zauberspruchs, nennt sich das Buff.

왘

Campen: Damit ist das Verstecken oder Verweilen gemeint, um dem nächsten PvP zu entgehen oder »Wunden« heilen zu lassen.

왘

Carebear: (Feigling) Das ist jemand, der einem Zweikampf, einem PvP, ausweicht.

왘

Caster: Caster haben die niedrigste Trefferquote und ihre Schilde die kürzeste Haltbarkeit. Deshalb brauchen sie besonders gute Unterstützung durch Zauberer.

왘

Char: (Charakter) Hierbei handelt es sich um eine Spielfigur, die von einem realen Spieler gesteuert wird. Man verwendet nach dem gleichnamigen Film auch verstärkt den Begriff Avatar.

왘

Cooldown: (Abkühlphase) Dies bezeichnet die Zeit, die verstreichen muss, bis ein Zauberspruch oder Gegenstand wieder verwendet werden kann.

왘

Crit: (critical) Steht für eine böse Schädigung durch Schüsse oder sonstige Treffer, die den Verlust des Spielers zur Folge haben kann.

왘

Crowd control: Hält mehrere Gegner von einem Angriff ab und erhöht die Zauberkraft.

왘

Dash, dashen: Bei manchen Spielen kann man die Geschwindigkeit erhöhen, indem man eine Richtungstaste doppelt anklickt.

왘

DC: (Disconnect) Online-Verbindung unterbrechen.

왘

DD: (Damage Dealer) Figuren, die einem Spieler großen Schaden zufügen können.

왘

DPS: (damage per second) Schaden, den ein Gegner pro Sekunde erzeugen kann. Dieser Wert ist wichtig für die Spieleprogrammierer, damit aus der Zeitdauer der Konfrontation die Schädigung des Spielers errechnet werden kann.

왘

Drop, dropen: Ist ein Mob besiegt, verliert er seine Gegenstände, die der Sieger aufsammeln sollte. Diesen Vorgang nennt man dropen.

왘

Dungeon: (Verlies) Räume, die meist von aggressiven Mobs besiedelt sind.

왘

Emote: (Emotion anzeigen) In einigen Spielen lassen sich Gefühlszustände ausdrücken. Damit alle Mitglieder einer Party sie mitbekommen, werden sie oft durch lustige Animationen verdeutlicht. Aufgerufen werden sie meist mit den Tasten (F8) bis (F12).

401

9.6

9

Computerspiele

왘

EXP, XP: (Experience) Die Erfahrung, die für einen Level-Up erforderlich ist.

왘

farmen: Ähnlicher Begriff wie grinden, bedeutet jedoch ein etwas vorsichtigeres Vorgehen.

왘

fc: (Falscher Channel/Chat) Hat man sich versehentlich im Chatkanal vergriffen und sendet an den falschen Mitspieler eine Nachricht, kann man sich mit dem Kürzel fc entschuldigen.

왘

grinden: Massenhaftes Abschlachten von Mobs, um im Spiel rasch voranzukommen.

왘

Healer: (Heiler, Schamane) Figur, die Mitglieder der Gruppe aufgrund ihrer Heilkräfte gesund machen kann. Sie ist noch kein kampfstarker Zauberer, kann aber zu einem aufsteigen.

왘

inc: (Incoming) Damit wird ausgedrückt: »Mir kommen Gegner entgegen.«

왘

Inv: (Inventar) So nennt man größere Gegenstände, auf denen oft Items abgelegt sind.

왘

Item: Ein Gegenstand, der für das Spiel von Bedeutung ist. Beispielsweise ein Schlüssel, mit dem sich eine Tür öffnen lässt, eine Rüstung oder eine Waffe, die im Kampf von Nutzen ist.

왘

Level-Up: (Level-Wechsel) Aufstieg in einen höheren Level.

왘

lfm: (looking for more) Die Gruppe sucht noch Spieler, die sich ihr anschließen wollen.

왘

lfp: (looking for party) Der Spieler ist auf der Suche nach einer Gruppe, die ihn aufnimmt.

왘

Lvl: (Level) Entwicklungsstufe, die eine Spielfigur aktuell erreicht hat.

왘

Mana: (Magie) Name für die Zauberkraft oder Abwehrkraft in Fantasyspielen. Der Begriff stammt aus Ozeanien und steht dort auch heute noch für Magie.

왘

MMOG: (Massively Multiplayer Online Game) Steht für Massen-MehrspielerOnlinespiel. Spiel, bei dem übers Internet eine große Anzahl von Spielern mitspielt.

왘

Mob: (Mobile Object) Ein automatischer Spielgegner, auch NPC. Das Programm reagiert meist so, dass der Angriff auf einen Mob sofort eine Abwehrfunktion mobilisiert. Die Aufmerksamkeitsfunktion des Mobs wird auf den realen Spieler gelenkt. Früher hießen Mobs einfach »Monster«. Seit Matrix ist auch »Agent« als Bezeichnung in Gebrauch. Wird ein Mob getötet, verliert er in vielen Spielen Items, die es einzusammeln gilt.

왘

Mount: Ein Fahrzeug oder ein anderes Fortbewegungsmittel, mit dem man in der Spielwelt schneller vorankommt als zu Fuß.

402


왘

MT: (Main Tank) Der Main Tank ist die defensiv stärkste Figur in der Gruppe, also derjenige, der den stärksten Angriffen widerstehen kann.

왘

Mudflation: Inflation innerhalb virtueller Spielewelten. Tritt insbesondere bei lang andauernden Spielen wie WoW auf. Da die aufgesammelten Dinge, Fähigkeiten und Reichtümer immer mehr werden, verlieren sie an Wert und Wirkung, weil sonst neu eintretende Spieler hoffnungslos benachteiligt wären.

왘

Newbie: Absoluter Neuling im Spiel.

왘

Noob: Jemand, der die Spielregeln absolut nicht begreifen will, also lernunfähig ist.

왘

NPC / NSC: (Non-player character) Figur, die vom Computer gesteuert wird. Meist ist es ein Monster (Mob), es kann aber auch ein Händler sein oder ein Auftraggeber (Questgeber).

왘

omw: (on my way) Mitteilung an die Gruppe, dass man eigene Wege geht oder sich bereits in Bewegung gesetzt hat.

왘

oom: (out of mana) Mitteilung eines Charakters an die Gruppe, dass ihm die Zauberkraft ausgegangen ist.

왘

oop: (out of party) Ein Spieler außerhalb der Gruppe leistet Unterstützung. Meist in der Hoffnung, in die Gruppe aufgenommen zu werden.

왘

Party: Gruppe innerhalb der virtuellen Welt eines Mehrbenutzerspiels, die sich gegenseitig unterstützt. Auch »Allianzen«, »Clans«, »Gilden«, »Squads« oder »Stämme« genannt.

왘

plvl: (powerleveling) Eine schwer zu definierende Bezeichnung, die für eine Spielphase stehen kann, in der möglichst viele Punkte gesammelt werden. Manche bezeichnen aber auch die Phase der Aktivierung zu einem Angriff mit massivem Einsatz aller Mittel, Zauber usw. als plvl.

왘

PvE: (Player vs. Environment) Der Modus, in dem ein Spieler nur gegen Mobs zu kämpfen hat, deshalb nennt man ihn auch PvM (Player vs. Mobs).

왘

PvP: (Player vs. Player) Zweikampf oder Kampf mehrerer Spieler gegeneinander. Manche Spiele wechseln in einen speziellen Modus, um solche Kämpfe austragen zu können.

왘

Quest: Aufgaben, die ein Spieler oder eine Gruppe erledigen soll. Oft handelt es sich um das eigentliche Spielziel.

왘

re: Damit drückt ein Spieler aus: »Ich bin wieder zurück.«

왘

Rezz: Wiedererweckung oder Wiederbelebung einer umgekommenen Spielfigur durch eine andere Spielfigur, meist direkt nach dem »Ableben«.

403

9.6

9

Computerspiele

왘

rh: (red Herring) Ablenkungsmanöver, das einen auf eine falsche Fährte locken soll. Beispielsweise ein Tunnel, der am Ende ins Freie zu führen scheint und – wenn man diese Stelle erreicht – doch nur vom Licht einer Fackel oder einer Lampe erhellt wurde.

왘

Skill: Eine bestimmte Eigenschaft der Spielfigur. Skills werden entweder vor dem Spiel festgelegt oder erworben, beispielsweise durch Training oder Aufnehmen eines Gegenstands.

왘

Spawn: Lokalität, an der die Monster oder Mobs eines Spiels auftauchen.

왘

Spell: Bezeichnung für Zaubersprüche.

왘

Squad: Spielergruppe innerhalb der virtuellen Welt eines Mehrbenutzerspiels, die sich gegenseitig unterstützt, auch »Allianzen«, »Clans«, »Gilden«, »Partys« oder »Stämme« genannt.

왘

Stamm: Gruppe von Spielern, die sich in der virtuellen Welt zusammengefunden haben. Meist fragt der Gründer oder Oberhaupt eines Stammes nach, ob der freie Spieler beitreten möchte. Bei manchen Spielen kann man mehreren Stämmen angehören.

왘

Stats: (Stati) Wichtige Zustände eines Avatars oder Spieler-Charakters. Sie werden entweder ständig in einer Leiste angezeigt oder können mit Hilfe eines Menüpunkts aufgerufen werden.

왘

Tank: Unter Tank versteht man eine durch Erfahrung und Zauber gestählte Figur, die die Angriffe der Mobs auf sich lenkt, um die anderen Mitglieder der Gruppe zu schonen oder vom Gegenangriff der Krieger und Zauberer aus der Gruppe abzulenken.

왘

Taunt: So bezeichnet man die Eigenschaft von Mobs, auf sich aufmerksam machen zu können. Sie ist vor allem für Tanks wichtig.

왘

Townen: Townen bedeutet, sich in die nächstgelegene Stadt zu teleportieren, um in Sicherheit zu sein oder lebenswichtige Produkte zu erstehen.

왘

Twink: Das ist der zweite Charakter eines Spielers, der bei Bedarf gewechselt, also mehr oder weniger parallel gespielt wird.

왘

wb: (welcome back) Begrüßung eines Spielers, der sich mit re zurückgemeldet hat.

왘

Wipe: Untergang einer ganzen Party, Gilde oder eines Stammes.

왘

wtb: (want to buy) Eine Spielfigur (Spieler) möchte etwas kaufen.

왘

wts: (want to sell) Ein Spieler will etwas verkaufen, wird auch mit vk (verkaufe) bezeichnet.

왘

wtt: (want to trade) Der Spieler möchte etwas tauschen.

왘

XP: Erfahrung, siehe EXP.

404

Noch mehr Spaß: ausgewählte Meilensteine der Computerspiele

Webseiten, die sich mit der Thematik Gamerslang befassen, gibt es im Internet nicht gerade reichlich. Dabei ist es nicht einmal die einzige »Fachsprache«, die sich mit der intensiven Computernutzung eingestellt hat. Ein witziger Beitrag zu diesem Thema findet sich unter dieser Adresse: http://www.informatikboard.ch/ games-allgemein/15618-mmorpg-slang-entziffert.html.

9.7


9.7.1

Defender of the Crown

Das Spiel erschien 1987 unter den Spielen für den Commodore Amiga auf dem Markt. Es war damals grafisch und soundtechnisch ein viel beachtetes Spiel. Defender of the Crown zählt zu den Strategiespielen, hat jedoch auch wenige Elemente von Actionspielen und Adventures. Es war das erste Spiel der Firma Cinemaware und stammte von dem Entwickler Jim Sachs. Da man das Spiel übereilt auf den Markt geworfen hatte, fehlte in der ersten Version das Schießen mit griechischem Feuer, was in den folgenden C64- und AtariST-Versionen möglich war. Schauplatz des Spiels ist das mittelalterliche England, was bereits im Vorspann bei den Figuren sichtbar wird. Dort gibt es einen Wilfred of Ivenhoe, einen Robin of Locksley und eine Rebecca of York. Alles Figuren aus Robin Hood und dem Roman Ivenhoe von Sir Walter Scott (1952). Die Zeit der Geschehnisse liegt laut Spieleinleitung im Jahr 1149 zur Zeit der Rückkehr von Richard Löwenherz vom Kreuzzug. Sechs große Regionalherren kämpfen um die Vorherrschaft auf der Insel. Zu Beginn des Spiels hat man die Möglichkeit, in die Figur des Ivenhoe, Cedric of Rotherwood, Wolfric the Wild oder Geoffrey Longsword zu schlüpfen. Nach einer weiteren Einweisung und Informationen zum Einkommen der eigenen Grafschaft bekommt man einen Übersichtsplan zu sehen. Zunächst ist es sinnvoll, sich mit Hilfe des Menüpunkts Read Map die Grafschaften näher anzusehen. Dort, wo das Pferdesymbol steht, ist man Herr im Haus. Alles, was nicht mit Burgen geschützt ist, kann ohne Weiteres annektiert werden. Dazu kauft man sich zunächst Soldaten (By Army). Im nächsten Schritt muss man die Mannschaften aufteilen in Burgbesatzung und Angriffsstreitmacht (Campaign Army und Transfer home to campaign army). Mit Move the campaign army kann man freie Territorien annektieren. Wichtig ist, nach jedem Spielzug die Armee mit Buy Army aufzustocken. Und es ist sinnvoll, die eroberten Länder mit Burgen zu sichern (By Army – Castle). Zwischendurch werden immer wieder Turniere abgehalten, in denen es Gebiete zu erringen gilt. Man sollte also tunlichst versuchen, siegreich daraus hervorzu-

405

9.7

9

Computerspiele

gehen. Hierzu muss man die eigene Lanze etwas unterhalb der Mitte des gegnerischen Schildes platzieren. Sobald man über Katapulte verfügt und die gegnerischen Fürsten noch nicht zu mächtig sind, kann man sie auch in ihren Burgen angreifen. Dazu muss mit dem Katapult eine Schneise in die Burgmauer geschossen werden.

Abbildung 9.30

Erobern der gegnerischen Burg

Damit die Schüsse gelingen, muss die Spannung des Katapults mit der Maus durch Herabziehen der Schale eingestellt werden. Nur, wenn sie stimmt, trifft der Stein die Mauer an der richtigen Stelle. Hat man alle Turniere siegreich bestritten und die gegnerischen Lords bezwungen, kann Richard Löwenherz zurückkehren, Robin wird entschädigt und man selbst mit Lob überhäuft. Wegen des großen Erfolgs erschienen zwei Nachfolgeversionen: 왘

2002: Digitally Remastered Edition

왘

2003: Robin Hood – Defender of the Crown, eine 3D-Version

Das Spiel ist heute auch als reines und kostenloses Onlinespiel verfügbar (http:// www.cinemaware.com/browser/dotc/final.asp#). Es kann mit den meisten Browsern gespielt werden, allerdings muss dazu Adobe Shockwave installiert sein.

406


Abbildung 9.31

9.7.2

Defender of the Crown als Browserspiel

America’s Army

Wer Spaß an Kriegsspielen hat, kommt an diesem Spiel nicht vorbei: America’s Army. Geschichte hat es schon deshalb geschrieben, weil es im Auftrag der United States Army und mit Geld vom Pentagon entwickelt wurde. Veröffentlicht wurde es am 17. Juni 2009. Laden kann man es sich kostenlos von dieser Seite: http://www.americasarmy.com/downloads/. Man sollte natürlich Englisch beherrschen, um es wirklich spielen zu können. Außerdem sei gleich gesagt: Es ist sehr anspruchsvoll, wenn nicht eines der schwierigsten Spiele überhaupt. Das kommt auch schon daher, weil man erst sehr umfangreiche Trainingseinheiten in detailgetreu nachgebildeten Trainingslagern absolvieren muss, bevor man in Kriegsgebiete entsandt wird. Wie in der Wirklichkeit eben. Nach dem Installationsvorgang des Games wird eventuell nach dem ersten Start das aktuellste DirectX installiert.

407

9.7

9

Computerspiele

Abbildung 9.32

Installation von America’s Army

Im Anschluss an eine intensive Grundausbildung kann man sich auch zum Sanitäter oder Scharfschützen ausbilden lassen. Zu den Ausbildungen gehören oft auch Tests, die es zu bestehen gilt. Im Internet kursieren inzwischen jedoch zahlreiche Lösungssammlungen. Auf den Kriegsschauplätzen kämpft man, wie in anderen MMOGs, meist in Gruppen gegeneinander. Wobei der Server die Figuren so darstellt, dass die eigene Gruppe immer als amerikanische Soldaten fungieren, während die gegnerische Gruppe wie Terroristen aussieht. Für diese wiederum gilt das Gleiche: Sie sehen sich als Amerikaner und die andere Gruppe als Terroristen. Die virtuelle Welt macht’s möglich (siehe Abbildung 9.33). Die bestandenen Kämpfe werden natürlich bewertet. Es gilt das Befolgen der sieben Grundsätze der Armee (Loyalität, Pflicht, Respekt, selbstloser Dienst, Ehre, Integrität, Mut), um hohe Werte zu erreichen. Das Spiel ist dazu gedacht, das Bild der Armee bei jungen Amerikanern positiv zu formen. Man nutzt es dazu, Freiwillige zu finden, die in die amerikanische Berufsarmee eintreten wollen. Daher werden erfolgreiche Spieler von Rekrutierungskräften per E-Mail angeschrieben.

408


Aus diesem Grund ist es ein sehr realistisch aufgebautes Spiel, da man darauf achten musste, dass kein falsches Bild entsteht.

Abbildung 9.33

Im Einsatz bei America’s Army

Lediglich Körpertreffer werden harmloser dargestellt, als sie in Wirklichkeit sind. Zu viel Blutspritzer im Spiel hätten es auf den Altersindex gebracht, und die erwünschten Zielpersonen hätten es gar nicht spielen dürfen. Alles andere ist sehr realitätsnah, so dass man als Einzelkämpfer kaum Chancen hat, lange zu überleben. Lediglich ein eingespieltes Team, in dem sich jeder auf den anderen verlassen kann, sichert das Überleben, zumal die Gegner ebenfalls gemeinsam vorgehen.

9.7.3

Spore

Ein Spiel, das in letzter Zeit für Furore gesorgt hat, nennt sich Spore. Es baut unverhohlen auf der Problematik um gentechnologische Forschungen auf und »überredet« den Spieler, sich selbst als Gentechnologe zu versuchen und völlig neue Kreaturen zu erschaffen. Ziel des Spiels ist – ähnlich wie beim Terraforming aus einzelligen Wesen, die auf einen Planeten verschlagen wurden oder dort entstanden sind –, über Mehrzeller bis zu großen Kreaturen Leben entwickeln zu helfen, das schließlich Raumfahrerkulturen hervorbringt. Entwickelt hat dieses Spiel die Firma Maxis, und vertrieben wird es von Electronic Arts. Will Wright, der bereits die Sim-Spiele erfunden hat, lieferte die Idee zu diesem Spiel.

409

9.7

9

Computerspiele

Vorgestellt wurde das Spiel bereits 2005 auf der E3, der Electronic Entertainment Expo in Los Angeles. In jenem Jahr und in dem darauffolgenden wurde es zum besten Spiel der Messe gekürt. Kaufen konnte man es jedoch erst ab Ende 2008. Das Spiel ist in fünf Entwicklungsphasen aufgeteilt: 왘

Zellphase Diese Spielphase wird in Art der früheren Computerspiele in 2D gespielt. Es geht darum, für die folgende Phase zu wachsen, sich fortzuentwickeln und Punkte zu sammeln. Schwächere Wesen kann man vertilgen, während man größeren Kreaturen besser aus dem Weg geht.

왘

Kreaturenphase Diese Spielphase läuft in einer reinen 3D-Welt ab. Vom Spielprinzip her bleibt sie jedoch gleich. Auch hier geht es darum, erfolgreich Nahrung zu finden, während man den Stärkeren möglichst zu entfliehen sucht. Als Währung dient die Nahrung. Um in den Stammeslevel zu gelangen, muss die Kreatur eine bestimmte Intelligenz erreichen.

왘

Stammesphase Dieser Spielelevel erinnert an die vielen Zivilisationsspiele. Es gilt einen mächtigen Stamm aufzubauen. Gegen Nachbarstämme kann man entweder kämpfen und sie unterwerfen, oder man bildet Allianzen mit ihnen. Hat man alle Stämme vereint, so beginnt der nächste Level.

왘

Zivilisationsphase Nun ist man Herr über eine Stadt und arbeitet daran, sie zur mächtigsten auf dem Planeten zu machen. Man kann Fahrzeuge und Gebäude errichten und betreiben. Gehandelt werden Gewürze, die man mit Hilfe von Gewürzbohrtürmen gewinnen kann. Ist der ganze Planet erobert, gelangt man zur nächsten Spielphase, die kein Ende kennt.

왘

Weltraumphase Nun kann man Raketenfahrzeuge entwerfen, mit denen die Kolonisation des Weltraums in Angriff genommen werden kann. Es gibt mehrere Möglichkeiten, im Weltall zu interagieren. Entsprechend den vorherigen Leveln kann man Planetenbewohner von Allianzen überzeugen, aber auch – wenn es sein muss – mitsamt dem ganzen Planeten vernichten. Andererseits ist es möglich, unwirtliche Planeten mit Hilfe von Terraforming bewohnbar zu machen. Auch dort gilt es den Gewürzhandel in Gang zu bringen. Unbewohnbare Planeten können über Kuppeln besiedelt werden. Wer von alledem nicht begeistert ist, kann sich als Glücksritter auf die Suche nach kostbaren Artefakten machen, die es auf manchen Planeten zu finden gibt. Sie können so kostbar sein, dass man ohne Weiteres davon leben kann, ohne Gewürzhandel betreiben zu müssen.

410


Das Spore-Labor Das Labor dient innerhalb des Spore-Universums dazu, in der Kreaturphase und nach der Paarung zweier Kreaturen die Nachkommen auszuformen. Dafür werden die Eier ins Spore-Labor übernommen. Dort kann, entsprechend den zur Verfügung stehenden Mitteln, die kommende Generation geformt werden. Dazu muss man in der Kreaturphase DNA-Punkte sammeln. Diese Punkte gehen in das DNA-Budget des Labors ein und werden zu Kreaturen verbaut. Teile, die man während der Weiterentwicklung nicht mehr benötigt, sollte man zuerst verkaufen, bevor man neue Teile zufügt, um das Budget optimal zu nutzen. Im Labor müssen Kreaturen entwickelt werden, die sich erfolgreich im kommenden Daseinskampf bewähren. Im Gegensatz zu dem eigentlich Spore-Spiel ist das Labor – oder wie es im Englischen heißt, der SporeCreatureCreator – kostenlos aus dem Internet downzuloaden. Er dient sozusagen dazu, Werbung für das Spiel zu machen. Außerdem ermöglicht es den Zugang zur Spore Community. Man kann mit dem Creator erstellte Monster für die anderen Spieler im Internet freigeben. Im Internet finden Sie das Spore-Labor unter http://eu.spore.com/ splash.cfm. Die Installation läuft wie bei größeren Windows-Anwendungen ab. Eine relativ aktuelle DirectX-Version ist allerdings erforderlich. Das Installationsprogramm meldet sich bei Bedarf entsprechend. Nach dem Start beginnen Sie entweder damit, eine Kreatur zu erschaffen, oder Sie laden sich eine aus dem Katalog. Dort sind auch die selbsterschaffenen und gespeicherten Kreaturen zu finden. Im Kreations-Modus finden Sie zunächst nur einen Rumpf, dessen Form per Zufall erzeugt wurde. Mit der Maus können Sie den Rumpf an einem seiner Enden verformen. Das Mausrad erlaubt eine Dickenänderung, wenn der Mauszeiger auf einem Wirbel steht. In der linken Fensterhälfte sind die Tabellen mit den Körperteilen und Sinnesorganen zu finden. In der kostenlosen Demoversion ist nur ein Bruchteil der üblichen Elemente enthalten. Man greift die gewünschten Elemente mit der Maus und zieht sie dorthin, wo sie sich bei der Kreatur befinden sollen (siehe Abbildung 9.34). Schiebt man sie zur Mitte, wird aus zwei symmetrisch angeordneten Teilen ein Teil. Zusätzlich lassen sich die Körperteile drehen und in ihrer Größe variieren. Bei Gliedmaßen werden meist die Gelenke als Kugel hervorgehoben. Ergreift man sie dort, lassen sich die betreffenden Teile in die Länge ziehen. Hat man die Kreatur so weit erschaffen, dass man ihre kinetischen und ästhetischen Fähigkeiten begutachten möchte, so macht man einen Testlauf.

411

9.7

9

Computerspiele

Abbildung 9.34

Der Schöpfer am Werk

Abbildung 9.35

Testlauf der neuen Kreatur

412


Das Icon zum Start befindet sich genau oben in der Mitte des Fensters. Mit zahlreichen Icons können die verschiedensten Bewegungen und Situationen getestet werden (siehe Abbildung 9.35). Dem erwachsenen Tier kann man frisch geschlüpfte Jungtiere hinzufügen, denn um diese ging es ja bei der »Laborarbeit«.

9.7.4

Abenteuer Marke Eigenbau – mit dem Unreal Development Kit

Wie wäre es mit der Entwicklung eines eigenen Egoshooters? Natürlich benötigt man dazu eine Game-Engine. Wie wäre es mit einer der besten, mit der Unreal Game-Engine, die wir schon von America’s Army kennen? Unreal bietet die Entwicklungsumgebung zum freien Download an, so können wir uns zumindest einmal ansehen, wie man so einen Egoshooter entwickelt oder wenigstens, wie an ihm gearbeitet wird. Wir müssten Musiker, Grafiker und Software-Entwickler in einer Person sein, um wirklich ein neues Spiel oder eine neue Szene auf die Beine stellen zu können. Also eigentlich nichts für einen Einzelkämpfer. Das Spiel Unreal, zu dem UDK als Unreal Developer Kit gehört, hatten wir bereits kurz erwähnt. Es wurde Ende der 90er Jahre von Epic Games und Digital Extremes entwickelt. Der Vertrieb durch GT Interactive begann im Jahre 1998. Die Spiele-Engine wurde zuvor in dreijähriger Arbeit von Tim Sweenley entwickelt. Sie wurde später nach dem Spiel Unreal (Unwirklichkeit) als Unreal Spiele-Engine bezeichnet und diente als Grundlage für die Entwicklung vieler weiterer Spiele, unter anderem auch für America’s Army. Aber auch Unreal selbst wurde weitergeführt. Mit einer wesentlich verbesserten Engine kam Unreal II 2003 auf den Markt, nachdem zunächst ein Bonuspack und später eine Erweiterung als Mission Pack herauskamen. Es gab auch noch eine Gold-Version und 2006 die Unreal Anthology. Zuvor war noch Unreal Tournament 2004 erschienen und danach Unreal Tournament 3. Wahrscheinlich werden weitere Versionen folgen. Die aktuelle Engine ist von ihrer Leistung her noch immer zeitgemäß und noch lange nicht ausgereizt. Sehen wir sie uns also an. Das Entwicklerwerkzeug Unreal Editor 4 kann man sich von folgender Seite im Internet laden: http://udn.epicgames.com/Main/WebHome.html

413

9.7

9

Computerspiele

Nach der langwierigen Installation können Sie das Programm aus dem Systemmenü heraus starten: Alle Programme 폷 Unreal Development Kit 폷 UDK 200911 폷 Editor Unreal Development Kit. Der erste Eindruck ist vielleicht abschreckend, weil vier Views mit einem roten Drahtwürfel angezeigt werden, außerdem der Content Browser und der Tipp des Tages. In der Tat zählt der Unreal Developer zu den etwas komplexeren Softwaresystemen. Man muss bedenken, dass damit ganze Welten geschaffen werden, die man frei durchwandern kann und die Tageszeiten haben, also ständig wechselnde Beleuchtungsverhältnisse. In der Welt agieren autonome Agenten, die Bewegungssequenzen selbständig ausführen und einander bekämpfen. Ein wichtiger Schlüssel zum System ist der Content Browser. Wie die übrigen Browser öffnet man ihn bei Bedarf über View 폷 Browser Windows. Zunächst einmal muss man wissen, dass der Editor grundsätzlich zwei Modi kennt: einen additiven und einen subtraktiven Modus. Der additive Modus beginnt mit einer leeren Welt, in die man etwas hineinstellen kann, der subtraktive mit einer Welt, die ausgehöhlt werden will. Anfangs wählen Sie über das Menü: File 폷 New 폷 Subtractive 폷 OK. Danach klicken Sie den Würfel in der schwarzen 3D-Ansicht an (siehe Abbildung 9.36). Mit der Funktion CSG Subtract (B) schneiden Sie den Würfel aus der Unreal-Welt heraus und erhalten Innenflächen, die mit einem Schachmuster ausgekleidet sind. Da uns der Raum etwas klein erscheint, klicken wir mit der rechten Maustaste auf das Cube-Icon (A) und erhöhen Y, das für die Breite auf 2048 steht. Nach dem Anklicken des Close-Buttons klicken Sie wieder auf Subtract (B), um den vergrößerten Raum auszuschneiden. Nun gilt es einen Innenraum ansprechend zu »tapezieren«, ihn mit einer Textur, einem Material zu überziehen. Hierzu benötigen wir den Content Browser. Diesen bekommt man entweder über View 폷 Browser Windows 폷 Content Browser oder, falls das Start Page-Fenster noch offen ist, indem man dort den Reiter Content Browser anklickt. Im oberen Auswahlbereich wählen Sie unter Object Type die Option Materials und unter Tags die Option Building. Nun werden Wandverkleidungen und Fliesen angezeigt. Für den Boden verwenden wir M_HU_Floors_BSP_gray_tiles und für die Wände M_HU_Walls_SM_BustedConcrete01. Dazu wählen wir das Material aus, ziehen es hinüber in die 3D-Ansicht und lassen es auf der Wand oder dem Boden los, wo wir es haben möchten.

414


Abbildung 9.36

Hohlraum erzeugt

Wenn Sie ein Problem mit der Maus und der Bewegung und Steuerung im Raum haben: Es geht auch ganz gut mit den Cursortasten, und mit (Bild½) und (Bild¼) kann man auf- und abtauchen. Wenn alles verkleidet ist, muss man noch das Licht »anknipsen«. Das gelingt mit einem Rechtsklick in den Raum und dem Menüpunkt Add Actor 폷 Add Light (Point). Ein Licht wird gesetzt, was man direkt an den beleuchteten Wänden erkennen kann. Nun muss noch LightmassImportanceVolume gesetzt werden. Dazu wählen Sie den Raum mit der linken Maustaste aus. Anschließend klicken Sie ebenfalls mit der linken Maustaste in der Icon-Leiste links auf den unteren Würfel (C in Abbildung 9.36) und wählen den Menüpunkt LightmassImportanceVolume aus. Danach gilt es nur noch die neue Welt zu errechnen. Das gelingt über den Menüpunkt Build 폷 Build all.

415

9.7

9

Computerspiele

Nach einer relativ kurzen Berechnung dürfte der Raum für den ersten Besuch fertig sein. Sollte es länger dauern, was man an dem langen roten Balken Swarm Agent Diagramm erkennen kann, so wurde für den Raum kein Importance Volume gesetzt (siehe Abbildung 9.37).

Abbildung 9.37

Rechnende Agenten

Um den Raum nun endlich zu betreten, klicken Sie mit der rechten Maustaste hinein und wählen den Menüpunkt Play from Here. Schon steht man bewaffnet in dem gerade erstellten Raum und kann ihn durchschreiten (siehe Abbildung 9.38). Die Decke ist natürlich nicht verkleidet und zeigt ihr blauweißes Standardmuster. Sollten wir den Raum erweitern wollen, geht das recht einfach. Die ganze Welt müssen wir uns nur wie einen Schweizer Käse denken. Der rote Würfel ist unser Käsemesser. Wir verschieben ihn einfach dorthin, wo wir etwas wegschneiden wollen, und klicken auf Subtract (B in Abbildung 9.36). Ruck, zuck haben wir aus dem einen Gang ein verwirrendes Labyrinth gezaubert. Vergessen Sie nicht, jedes Mal mit Build All alles neu durchrechnen zu lassen. In einem Netzwerk kann UDK übrigens auch andere Rechner nutzen, um die Berechnungen zu beschleunigen. »Auf den Feind richten!« (Anweisung auf einem US-Raketenwerfer) *** »Anfliegende Geschosse haben immer Vorfahrt!« *** »Nachdem Sie eine Melone zerschnitten haben: Ihre Obsttötungsfähigkeiten sind erstaunlich!« – aus Call of Duty 4 416


Abbildung 9.38

Ein spärlich beleuchteter Flur ...

Aufgrund der Komplexität ist es natürlich nicht möglich, im Rahmen dieses Buches eine weiterreichende Einführung zu geben. Das ist auch nicht erforderlich, weil die Dokumentation, wenn auch in Englisch, sehr umfangreich ist. Für Nicht-Anglisten gibt es auch einige deutsche Tutorials im Internet. Zudem existieren eine Reihe einführender Videosequenzen, die man sich ansehen sollte. Möchte man ernsthaft Szenen entwickeln, braucht man zudem viel Geduld und den Willen, die erforderliche Einarbeitungszeit hinter sich zu bringen. Zur Dokumentation, die ausschließlich übers Internet verfügbar ist, gelangt man über den Content Browser oder die Startpage, in deren Menüzeile sich ein Link namens Documentation befindet. Über diesen Link wird eine Webseite geöffnet, die einen Überblick über die gesamte UDK bietet. Getting Startet ist natürlich der sinnvollste Link, um die Einarbeitungsphase zu beginnen. Wenn man das UDK noch nicht ganz beherrscht, so heißt das natürlich nicht, dass man keinen Blick auf eine fertige Unreal-Welt aus der Hand von Profis werfen darf. Dazu öffnet man einfach eine der Unreal-Dateien, die dem UDK beigefügt sind: File 폷 Open. Man kann diese Welten wie eben den Flur betreten, aber auch über eines der Icons oben rechts im Fenster gehen, und zwar mit Start on PC oder Start. 417

9.7

9

Computerspiele

Sehenswert ist auf jeden Fall VCTF_Necropolis.udk (siehe Abbildung 9.39), aber auch die GDC_FeaturesDemo.udk sollte man nicht verpassen, weil sie zeigt, was Unreal alles kann.

Abbildung 9.39

Blick von einem Turm in Necropolis

»Das Ende der Welt ist angebrochen, bitte die Rechner runterfahren.« – Anonymus

9.8

Lesen Sie weiter


Beschreibung

http://www.mobygames.com

Spiele-Übersichten

http://www.mobygames.com/browse/ games/list-games/

Spiele-Liste

http://www.mobygames.com/stats/ top_games/k,all:5ftime:5fbest/

Bestenliste der Computerspiele

418

Lesen Sie weiter

URL

Beschreibung

http://www.freeware.hartberg.info/ freeware.php?programm=25&seite=5

Nim-Spiel einfach

http://www.freeware.hartberg.info/ freeware.php?programm=17&seite=4

Nim-Spiel

http://www.ifiction.org/games/play.phpz? cat=&game=235&mode=html

Adventure in Deutsch

http://www.csd.uwo.ca/Infocom/ download.html

Zork-Spiele 1–3

http://www.ifiction.org/games/ index.php?cat=2

Online-Zork

http://www.mv.com/ipusers/xlisper/zil.pdf

Handbuch von Infocom

http://www.csd.uwo.ca/Infocom/Articles/ small.html

Programme für die Z-Machine schreiben

http://www.heise.de/tp/r4/artikel/9/9596/ Artikel zu Zork 1.html http://www.wichman.org/roguehistory.html

Die Rogue-Story von Wichman

http://www.atarimagazines.com/cva/v1n1/ Spacewar-Seite spacewar.php http://de.wikipedia.org/wiki/Ostomachion

Altes Legespiel

http://www.didmath.ewf.uni-erlangen.de/ Vorlesungen/Geometrie_ HS/3_Figuren_ Koerper/Flaecheninhalt/tangram3.htm

Tangram

http://www.maennerseiten.de/tangram.htm Tangram http://www.cse.yorku.ca/~roumani/ fortran/ftn.htm

freie Fortran-Compiler

http://www.log-in-verlag.de/wwwredlogin/ Artikel zur Geschichte der ComputerArchiv/2009/Heft157 /Internetquellen spiele %20LOG%20IN%20Heft%20Nr_157.html http://www.kriegsspiel.org.uk

Kriegsspiele-Seite

http://www.chip.de/downloads/America-sArmy_13012605.html

3D-Shooter der amerikanischen Armee

http://de.wikipedia.org/wiki/ComputerRollenspiel

Wikipedia-Artikel zu Computerrollenspielen

http://www.armory.com/~dlp/dnd1.html

Brief der Spieleentwickler von DnD

http://www.permadi.com/tutorial/raycast/

Anleitung zum Raycasting

419

9.8

9

Computerspiele

URL

Beschreibung

http://www.springerlink.com/content/ r295881786052126/

Forschungsarbeit für 3D-Darstellungen (1925) von Dr. Paula Wolmeringer

http://www.schwalfenberg.com/Content/ index.php?/archives/37-NimmSpiel.html#extended

Nimm-Spiel

http://udn.epicgames.com/Main/ WebHome.html

Unreal-Entwickler-Homepage

http://www.unrealed.info/forum/

Seite mit deutschen UDK-Tutorials

http://www.pivotforum.de/showthread.php?tid=15471&pid=106313 #pid106313

deutsches UDK-Tutorial

420

»Das Internet ist bloß ein kurzer Hype.« – Bill Gates Das Internet ist nach dem Computer und durch den Computer zur größten Revolution der letzten 15 Jahre geworden. Es hat mehr Auswirkungen auf das alltägliche Leben als der Computer ohne Internet. Und was noch entscheidender ist, seine Möglichkeiten sind nicht einmal annähernd ausgenutzt.

10

Das Netz der Netze

1957

1958

1983

1992

1998

2002

Sputnik ARPA TCP/IP WWW/Browser Browser-Krieg Web 2.0

10.1

Ich hab’s gesagt

Es war die Zeit des Kalten Krieges. Um es genau zu sagen, es begann gerade – in diesem denkwürdigen Jahr 1957. Was das Jahr so ungewöhnlich machte, kreiste, wie im Radio zu hören war, laut piepsend um den Globus und nannte sich Sputnik. Es war ein Jahr, das Geschichte schreiben sollte, als das rhythmische Piepen beharrlich die Erde umrundete. In diesem Jahr wurde den Amerikanern klar, dass sie Gefahr liefen, technisch für immer den Anschluss zu verlieren. Etliche

421

10

Das Netz der Netze

Möchtegern-Propheten hatten das schon Monate, wenn nicht gar Jahre, vorausgeahnt. Ihr Satz »Ich hab’s ja immer gesagt!« sollte ein Synonym für diese Zeit werden. Beide Großmächte hatten sich reichlich mit Raketenassen aus dem besiegten Deutschland eingedeckt. Ein Wettrennen stand bevor, und das Ziel war der Weltraum, später, wie wir alle wissen, der Mond. Aber die Amerikaner hatten zu Beginn des Kalten Krieges dessen Dynamik völlig falsch eingeschätzt. Als Reaktion auf die nationale Katastrophe, dass die Russen den ersten Satelliten in den Orbit geschossen hatten, verstärkte man die Anstrengungen auf allen anderen technischen Gebieten. Unter anderem auch auf dem Gebiet der Computertechnologie.

10.1.1

Die Anfangsidee

»Das Internet wurde von der DARPA, dem amerikanischen Militär, entwickelt, um bei einem atomaren Angriff nicht die gesamte Computerleistung zu verlieren, also noch mit Interkontinentalraketen zurückschlagen zu können. Das geht ohne Computer nicht.« So lautet die Ansicht, die zu diesem Thema weit verbreitet ist. Das ist zwar teilweise richtig, jedoch eben nicht ganz. Der Name DARPA, ursprünglich ARPA, steht zwar für eine militärische Einrichtung, nämlich für Advanced Research Projects Agency, und die Entwicklung des Internetvorgängers wurde auch zum großen Teil von dieser Einrichtung finanziert, die eigentlichen Entwickler und Schöpfer kamen jedoch hauptsächlich aus der Privatwirtschaft oder waren Zivilisten, und das Interesse dahinter war ebenfalls recht zivil. Die DARPA DARPA steht für Defense Advanced Research Projects Agency und ist der Name einer Behörde des Verteidigungsministeriums der USA. Über diese Einrichtungen werden vorrangig Forschungsprojekte mit militärischem Hintergrund gefördert. Gegründet wurde die DARPA unter dem Namen ARPA am 7.2.1958 von Präsident Dwight D. Eisenhower als Reaktion auf den sogenannten Sputnikschock von 1957. Der Etat der Behörde beträgt etwa drei Milliarden Dollar. Heute beschäftigt sie sich zu einem großen Teil mit den Problemen der Terrorismusbekämpfung. So wurde 2003 ein Wettbewerb ausgeschrieben, in dem es darum ging, ein Übersetzungsprogramm aus einer vorher unbekannten Sprache ins Englische zu erstellen. Der Wettbewerb wurde von dem Deutschen Franz-Josef Och gewonnen.

422

Ich hab’s gesagt

Üblicherweise sind die Projekte der Behörde nicht streng geheim und man kann sich im Internet darüber informieren, die Homepageadresse der DARPA lautet http:// www.darpa.mil/. Das bisher erfolgreichste Projekt der Behörde war das ARPANET, aus dem später das Internet hervorging.

Die DARPA selbst hatte ursprünglich ein sehr weites Arbeitsfeld, unter anderem hauptsächlich das, was später die NASA übernahm. Als Antwort auf den Sputnikflug gegründet, sollte man überwiegend in der Raumfahrt tätig sein. Mit Gründung der NASA verlor man jedoch den entsprechenden Etat und musste auf andere Tätigkeitsfelder ausweichen. Eines dieser Felder war die noch junge EDV. Da die ARPA selbst keine Entwicklungen machte, sondern in erster Linie universitäre Forschungseinrichtungen beauftragte, hatte man Probleme mit den unterschiedlichen EDV-Anlagen der einzelnen Institute. Keiner der Rechner war mit einem anderen Rechner kompatibel, und zur Bedienung musste man für jeden Rechner spezielle Befehle erlernen. So entstand die Idee, die Rechner durch eine einheitliche Technik zu verknüpfen, so dass man auf einfache Weise über die Datenverarbeitung miteinander kommunizieren und Daten übertragen konnte. Vor allem aber sollte die Vernetzung der Rechner eine höhere Rechnerkapazität für die einzelnen Forschungsstätten bewirken. Dieser Wunsch war der eigentliche Vater des ARPA- und des späteren Internets. Nachdem das Projekt zunächst abgelehnt wurde, wurde es 1965 wieder aufgenommen und 1969 eine erste funktionsfähige Version vorgestellt.

10.1.2

Dezentrales Netz und vermittelte Datenübertragung

Unter einem dezentralen Netz versteht man ein Netzwerk, das über keinen Master-Rechner verfügt. Es gibt also keinen Rechner, der in der Mitte eines Knotens sitzt und über den alle Kommunikation läuft. Damit trotzdem alle Rechner erreichbar sind, sollte jeder Rechner mit jedem Rechner verbunden sein. Man spricht hier von Vermaschung des Netzes. Eine 100 %ige Vermaschung realer Netze ist jedoch nicht möglich. Dezentrale Netze funktionieren allerdings bereits sehr ausfallsicher, wenn nur der Großteil der Rechner miteinander verbunden ist. Insbesondere die Paketvermittlung hielten die Fachleute von den Telefongesellschaften damals für völlig undurchführbar. Vor allen Dingen sollte so etwas doch extrem fehleranfällig sein. Inzwischen werden Telefongespräche zum großen Teil über das Internet übertragen, und die Befürchtungen von damals haben sich als völlig unbegründet herausgestellt.

423

10.1

10

Das Netz der Netze

Paketvermittlung Die Paketvermittlung hat, auch wenn der Name das nahelegt, nichts mit dem Gütertransfer zu tun. In einem paketvermittelten Netz gibt es keine Direktverbindungen wie im Telefonnetz, wo eine Leitung vom Anrufenden zum Angerufenen geschaltet wird. Es wird einfach ein Bruchstück der zu übertragenden Information mit der Zieladresse ins Netz geschickt. Jede Zwischenstation ist nun bestrebt, das Paket so weiterzusenden, dass es möglichst nahe ans Ziel kommt. Am Ziel werden alle Pakete einer Nachricht wieder zusammengesetzt.

Man hat sich die sogenannten IMPs ausgedacht, um die völlig verschiedenen Architekturen der Großrechner miteinander kommunizieren zu lassen. Ein solcher Interface Message Processor war ein selbständiger Computer, ein Minicomputer, ähnlich der PDP-8. Er nannte sich DDP-516, war von Honeywell Bull und nur dazu da, die Verbindung zu anderen IMPs aufzubauen und Daten zu übertragen. Dabei galt es eventuelle Übertragungsfehler zu vermeiden, zu erkennen und zu beheben. Ein spezielles Protokoll wurde entwickelt, mit dem der Datenverkehr gesteuert werden konnte. Außerdem mussten die IMPs von der Hardware umgerüstet werden, damit sie ihrer Aufgabe gerecht werden konnten. Der erste IMP war – als er von Honeywell zur Firma BBN kam, die ihn für seine Aufgaben vorbereiten sollte – aufgrund von Missverständnissen in den Konstruktionszeichnungen völlig funktionsunfähig. Es dauerte über ein halbes Jahr, ihn einsatzfähig zu machen und das erste einsatzfähige Modell an die UCLA (University of California, Los Angeles) zu liefern, die ihn mit ihrem Sigma-7 Mainframe verband. Das SRI (Stanford Research Institute) erhielt den zweiten IMP für ihre SDS-940, und somit stand das kleinste denkbare Netzwerk, die Verbindung zwischen zwei Rechnern (siehe Abbildung 10.1). Neben der Hardware war auch an der Software und insbesondere an den Protokollen gearbeitet worden. Die Gruppe, die an den Protokollen arbeitete, kam auf die Idee, eine Art Sitzungsprotokoll zu erstellen. Die Arbeit blieb an einem gewissen Steve Crocker hängen. Er verfasste das Protokoll in besonders kooperativem Ton und gab ihm den Namen »Ersuchen um Stellungnahme« – Request for Comments, abgekürzt RFC. Dieser erste RFC wurde noch mit Schreibmaschine getippt und per Briefpost versandt. Trotzdem kann man den RFC 1 heute natürlich auch im Internet lesen: http://tools.ietf.org/html/rfc1. Die Einrichtung der RFCs wurde bis heute beibehalten. In ihnen ist praktisch die gesamte Geschichte des Internets in technischen Anforderungen und Arbeitsprotokollen festgehalten. Auch die bald einsetzende Arbeit an dem grundlegenden TCP/IP-Protokoll ist darin zu finden (RFC 791 und RFC 793). Genauso wie später die Entwicklung des HTTP-Protokolls (RFC 1945). Selbst die Geschichte des Internets war einen RFC-Eintrag wert: http://tools.ietf.org/html/rfc2235.

424

Ich hab’s gesagt

1969 galt es einen ersten inoffiziellen Test durchzuführen. Wochenlang hatten sich die Techniker der Universität von Kalifornien auf das erste Login mit Hilfe von Übungen an Terminals vorbereitet. Es sollte nichts mehr schiefgehen. Charley Kline, ein Student dieser Universität, wählte am 29. Oktober 1969 den IMPRaum des SRI. Jeder IMP hatte eine Art Telefon, mit dem sich die Techniker parallel zur Datenübertragung fernmündlich verständigen konnten. Um eine Übertragung zu starten, musste zunächst ein Login-Befehl gesendet werden. Er bestand aus den drei Großbuchstaben »LOG«. Die Verbindung war schlecht, und Rechner wie Klimaanlagen waren nicht gerade leise. Kline schrie in die Muschel: »Ich tippe jetzt ein L!« Er tippte auf die entsprechende Taste und wartete einen Moment. »Haben Sie das L?«« »Ich habe eine 114!«, klang es leise in der Muschel. Kline durchwühlte die Zeichentabellen und stockte einen Moment. Das war nicht dezimal und nicht hexadezimal. Sollte ein Fehler vorliegen und die Datenübertragung nicht funktionieren? Da fiel sein Blick auf die Spalte mit den Oktalzahlen, hier stand für das L eine 114. Er nickte zufrieden und tippte ein O. »Haben Sie das O?« »Ich habe 117«. Das war richtig. Dazu brauchte man keine Tabelle, nach L kamen M und N und schließlich das O. Kline tippte ein G. Stille! Als Kline schon unruhig wurde, klang es lapidar aus der Leitung: »Der Rechner ist gerade abgestürzt!« Wie sich herausstellte, lag die Problematik darin, dass die Rechner sich bei dieser ersten Remote-Anwendung gegenseitig wie Terminals behandelten. Eine echte Rechner-Rechner-Kommunikation war noch utopisch, aber Terminals konnte man ohne viel Programmieraufwand bedienen. Das Programm vervollständigte nun nach dem Erhalt des G auf GIN und sandte die drei Buchstaben zurück. Terminals kommunizierten aber buchstabenweise, und so kam es zum Absturz. Der Fehler wurde noch am gleichen Tag behoben und der erste Test erfolgreich wiederholt. Natürlich sollten bereits in der ersten Stufe mehr als zwei Großrechner miteinander vernetzt werden. So wurde das Netzwerk mit zwei weiteren IMPs auf die Knoten Stanford Research Institute, University of Utah, University of California in Los Angeles und die University of California von Santa Barbara ausgebaut (siehe Abbildung 10.1).

425

10.1

Das Netz der Netze

Abbildung 10.1

Karte des ersten ARPA-Netzes aus zwei Mainframes mit zwei IMPs

Abbildung 10.2

Originalzeichnung aus der ARPA von Alex McKenzie

Quelle: www.scientificamerican.com

10

426

Ich hab’s gesagt

Der fünfte Knoten wurde bei Bolt, Beranek and Newman (BBN) eingerichtet, der Firma, die die IMPs für das Netz entwickelt hatte. Von dort konnten nun die rasch mehr werdenden anderen Knoten ferngewartet werden, was den Betrieb des Netzwerks wesentlich erleichterte. Es wurde ein sogenanntes NCC, ein Network Control Center, eingerichtet, das die Zuverlässigkeit des Netzwerkes erhöhen sollte. Man richtete eine Selbstwähleinheit ein, die einmal pro Tag alle Modems des Netzwerkes anwählte und anhand des Antwortsignals überprüfte, ob sie fehlerfrei funktionierten. Dabei brachte eines der inzwischen fast 50 Modems immer eine Fehlermeldung. Man ließ das System also wählen und hörte die Signale auf der Fernsprechanlage mit. Der Techniker staunte nicht schlecht, als er statt des aufdringlichen Piepsens eine Männerstimme schimpfen hörte: »He Martha, das ist schon wieder dieser Irre, der immer nur pfeift.« Erst waren nur die Universitäten an der Westküste vernetzt, der erste Rechner an der Ostküste war der bei BBN. Bereits 1971 bestand das ARPANET aus 15 Knoten mit 23 Rechnern und wurde jeden Monat um einen Knoten größer. Zwei Jahre später, 1973, kamen die ersten Knoten außerhalb Amerikas ans Netz, es waren Rechner am University College of London in England und am Royal Radar Establishment von Norwegen. Die Entwicklung des TCP-Protokolls war die letzte große Fördermaßnahme am Netzwerk, die von der DARPA ausging. 1975 ging die Verantwortung für das ARPANET an die Defense Communications Agency. Das TCP konnte 1977 in einem aufwendigen Experiment seine Tauglichkeit unter Beweis stellen. Die Verantwortlichen Bob Kahn und Vinton Cerf wollten die Zuverlässigkeit des neuen Protokolls einerseits dadurch beweisen, dass sie Daten eine möglichst weite Strecke zurücklegen ließen und dabei möglicht verschiedene Übertragungstechniken nutzten. Ausgangspunkt war ein Kleintransporter, der über einen Sender und einen damit verbundenen Minicomputer verfügte. Die Daten aus dem Computer wurden während der Fahrt über den San Francisco Bayshore Freeway zur BBN nach Virginia übertragen. Von der BBN wurden die Daten per SATNET zum Royal Radar Establishment nach Norwegen übertragen, von wo aus sie über ein Seekabel nach England geschickt wurden. In London schickte man die Datenpakete wieder mit Hilfe von SATNET zurück in die USA, zum eigentlichen ARPANET, wo sie am USC Information Science Institute schließlich ausgewertet wurden. Die zurückgelegte Strecke betrug mehr als 151.000 km – also dreimal um die Erde oder die halbe Strecke bis zum Mond (siehe Abbildung 10.3). Vinton Cerf sagte nach dem erfolgreich abgeschlossenen Experiment den berühmt gewordenen Satz: »Wir haben nicht ein einziges Bit verloren!«

427

10.1

Das Netz der Netze

© ARPANET; http://commons.wikimedia.org/

10

Abbildung 10.3

Das ARPA-Net im Jahre 1977

Danach wurde das ARPANET als ursprüngliche Forschungsaufgabe der DARPA 1978 offiziell für beendet erklärt. Im Schlussbericht heißt es: »Dieses ARPA-Programm hat nichts weniger als eine Revolution in der Computertechnologie hervorgebracht und war eines der erfolgreichsten Projekte, das die ARPA je durchgeführt hat. Das volle Ausmaß des technischen Wandels, der von diesem Projekt ausgeht, wird sich vielleicht erst in vielen Jahren ermessen lassen.« Der letzte große Auftrag, das Transmission Control Protocol/Internet Protocol, kurz TCP/IP, wurde erst 1983 als offizieller Standard eingeführt. Bereits vorher hatte sich gezeigt, dass die Nutzung des Netzes durch die Universitäten eine verstärkte Nutzung durch die Militärs verhinderte. Daher spaltete man das Netz in zwei Teilnetze auf, in das ARPANET und das MILNET. Die Technik des ARPANETs war schon zu Anfang von der BBN veröffentlicht worden, so konnte man problemlos selbst Netzwerke in kompatibler Technik einrichten.

428

IP-Adresse und Domainname

Unter der Federführung der amerikanischen National Science Foundation (NSF) wurden die Netzwerke der wichtigsten Forschungszentren um das ARPANET immer weiter vernetzt. Die Verbindungen zwischen den Teilnetzen wurden als Backbones bezeichnet, und das Ganze erhielt Ende der 80er Jahre den Namen Internet. In Europa gab es kurzzeitig ein europäisches Projekt namens COSINE, das ein TCP-fremdes Protokoll einsetzte. Doch TCP/IP war so erfolgreich, dass man gezwungen war, es auch zu nutzen, wollte man nicht für immer ausgegrenzt sein. Es entstand das EuropaNET, an das auch das Deutsche Forschungsnetz DFN angeschlossen wurde. Mit der Möglichkeit für den normalen Bürger, über einen Internetprovider ebenfalls Zugang zum Netz der Netze zu bekommen, nahm die Nutzerzahl Ende der neunziger Jahre explosionsartig zu.

10.2


Rechner im Netzwerk müssen erreichbar sein, dazu besitzen sie eine eindeutige Adresse und werden über sie adressiert. Diese Erreichbarkeit von Rechnern übers Netz ist im IP-Protokoll geregelt (RFC 790, RFC 1166, RFC 2460). Diese Adresse, sowohl vom Sender als auch vom Empfänger, steht im Kopf eines jeden Datenpaketes. Bei Datenpaketen, die zur gleichen Nachricht gehören, sind die Adressen natürlich gleich.

10.2.1

Nichts als Zahlen

Die IP-Adressen sind eigentlich nur eine Zahl. Je nachdem, wie man sie darstellt, kann man sie als 32-stellige Binärzahl schreiben oder in jeder anderen Form, in der man Zahlen zu schreiben vermag. Üblich ist jedoch eine Schreibweise mit Punkten nach jeweils drei Ziffern, wobei die drei Ziffern für 1 Byte stehen, also dezimal geschrieben sind. Deshalb können sie auch nicht größer als 255 sein. Eine IP-Adresse wie z. B. 85.88.3.146

würde hexadezimal so dargestellt: 55.58.3.92

und binär: 01010101.01011000.00000011.10010010 01010101010110000000001110010010

429

10.2

10

Das Netz der Netze

Also eigentlich ist diese IP-Adresse eine Schreibweise der Zahl 4267399958. Mit so einer langen Zahl kann man schon eine ganze Reihe von Rechnern adressieren. Wenn Sie so wollen, können Sie sich das Internet auch als sehr lange Straße vorstellen, und dieser Rechner hier hätte die Hausnummer 1431831442. Praxis: IP-Adresse ermitteln Möchte man die IP-Adresse einer bestimmten URL wissen, so gibt es dazu mehrere Möglichkeiten. Beispielsweise zeigt der folgende IP-Befehl nach seinem Aufruf die IP-Adresse einer Webseite an: ping <Webadresse>

Dazu wurde er freilich nicht gemacht. ping ist dazu da nachzuprüfen, ob eine bekannte Adresse auch in Betrieb ist. Wenn der jeweilige Server nicht läuft, nutzt einem also die schönste Webadresse nichts. Etwas anderes ist es mit diesem Befehl: nslookup <Webadresse>

Noch besser geht es mit einer speziellen Webseite, die zusätzliche Informationen liefert: http://whois.to/<Webadresse>.

10.2.2 Noch mehr Zahlen: IPv6 Eigentlich könnte man meinen, so viele Hausnummern müssten ausreichen, um die Welt des Web ausreichend zu adressieren. Das ist jedoch nicht der Fall. Mit 32 Binärziffern kann man bis 4294967295 adressieren. Das sind knapp 430 Millionen Hausnummern. Das reicht bei weitem nicht aus, um den Bedarf zu decken. Selbst wenn wir nur jedem Menschen eine Adresse zuordnen wollten, wäre es schon viel zu wenig. Deshalb hat man längst eine neue Adressierung festgelegt, die sich IPv6 nennt, die alte bekam zur Unterscheidung den Namen IPv4. Statt 32, wie bei der IPv4, nutzt man bei der IPv6 128 binäre Ziffern. Auf diese Weise lassen sich wesentlich mehr Webseiten adressieren als mit der alten Adressform. 2 hoch 128 ergibt eine ganz beachtliche Zahl. Nämlich 3,4028236692093846346337460743177e+38 oder in normaler, dezimaler Schreibweise 340.282.366.920.938.463.463.374.607.431.768.211.456. Das sieht zwar sehr gewaltig aus, doch wie gewaltig, das registriert man erst, wenn man die Adressen gleichmäßig über die Erdoberfläche verteilt: So kommen auf jeden Quadratmillimeter 665.570.793.348.866.944 Adressen (natürlich nur, wenn man die Erde als ideale Kugel versteht).

430


Durch die Adressgröße lässt sich die IPv6-Adresse nun nur noch schlecht als Dezimalzahl darstellen. Eine IPv6 in der Schreibweise der IPv4-Adressen würde so aussehen: 145.061.134.003.134.213.167.094.023.251.034.055.152.022.213.187

Eine solche Zahl lässt sich nicht mehr handhaben, deshalb hat man sich darauf geeinigt, IPv6-Adressen als Hexadezimalzahlen darzustellen. Man fasst jeweils vier Zahlen zusammen und trennt sie durch Doppelpunkte. Schon sehen sie viel ungefährlicher aus, wie beispielsweise diese Seite zu PCs und IPv6: 2a00:d00:ff:131:94:228:131:131

Diese Adressen sind jedoch für Webseiten noch nicht so weit verbreitet, wie man vielleicht denkt. Möchten Sie Webseiten mit den neuen Adressen ausfindig machen, nutzen Sie am besten spezielle Suchmaschinen wie: http://sixy.ch/.

10.2.3 Stets zu Diensten: das DNS Obwohl IP-Adressen ziemlich scheußlich daherkommen, sind sie für Rechner ideal. Es sind Zahlen, die rasch von Binärcode in lesbare Zahlformate und wieder zurück gewandelt werden können. Zum Surfen sind sie denkbar ungeeignet. Daher ist man bald nach der Erfindung der IP-Adressen dazu übergegangen, diesen klarschriftliche Namen gegenüberzustellen, die von uns heute genutzten URLs. Die Umsetzung erfolgte erst mit einer Liste, der sogenannten Hosts-Datei, später mit dem DNS-Serversystem – wobei die Hosts-Datei mit der Einführung des DNS (Domain Name System) nicht abgeschafft wurde. Sie ist als Hilfseinrichtung für Netze verfügbar, falls das DNS nicht genutzt wird. Das DNS zählt zu den Internetdiensten. Eigentlich ist es der wichtigste Dienst im Internet: Jedes Mal, wenn wir eine URL eingeben, wird dieser Dienst benötigt, um die zugehörende IP-Adresse zu ermitteln. Damit nicht jeder Beliebige Domainnamen festlegen kann, mussten diese zugeteilt werden. Dafür sind heute die sogenannten Network Information Center, die NICs, zuständig. Praxis I: Hosts-Datei unter Windows Schauen wir uns die Hosts-Datei unseres Rechners einmal an. Das kann man mit jedem Editor machen. Wir finden sie bei Windows unter C:\windows\system32\ drivers\etc. Unter Windows Vista hat sie folgenden Inhalt: # Copyright (c) 1993-2006 Microsoft Corp. # # This is a sample HOSTS file used by Microsoft TCP/IP for Windows.

431

10.2

10

Das Netz der Netze

# # # # # # # # # # # # # # # #

This file contains the mappings of IP addresses to host names. Each entry should be kept on an individual line. The IP address should be placed in the first column followed by the corresponding host name. The IP address and the host name should be separated by at least one space. Additionally, comments (such as these) may be inserted on individual lines or following the machine name denoted by a '#' symbol. For example: 102.54.94.97 38.25.63.10

127.0.0.1 ::1

Abbildung 10.4

432

rhino.acme.com x.acme.com

localhost localhost

Die Hosts-Datei unter Windows Vista

# source server # x client host


Was kann man nun mit so einer Datei anfangen? Gewiss kennen Sie auch die Möglichkeit bei modernen Telefonen, hinter Kurzwahlnummern die Telefonnummern der Verwandten und Freunde zu verstecken. Warum soll das mit der Hosts-Datei nicht auch gehen? Dazu benötigt man natürlich zunächst einmal die IP-Adressen der Webseiten, die wir häufig aufrufen wollen. Unter Windows gelingt das über eine Konsole mit Systemmenü 폷 cmd 폷 ping . Statt gibt man die jeweilige Internetadresse an, beispielsweise www.galileopress.de. Das ergibt zwar eine IP-Adresse, aber Galileo hat natürlich einen Proxy, so dass wir an dieser Stelle nicht sehr weit kommen. Aber mit etwas Geduld findet man rasch ein paar IP-Adressen und kann sich damit den Zugang abkürzen. Hier ein Ausschnitt aus der Hosts-Datei mit Kürzeln für Google, Sun und DENIC: # #

102.54.94.97 38.25.63.10

rhino.acme.com x.acme.com

127.0.0.1 ::1

localhost localhost

74.125.43.99 137.254.16.57 81.91.170.12

g2 s2 d3

# source server # x client host

# google.de # Oracle Sun # DENIC

Es genügt, die Datei zu speichern, bevor man ein neues Kürzel im Browser versucht. Anstatt die kompletten Webadressen einzugeben, reicht es nun, g2 oder d3 in die URL-Zeile zu tippen. Das Ganze funktioniert natürlich nicht nur bei Windows. Praxis II: Hosts-Datei unter Linux Unter Linux gibt es die Hosts-Datei ohnehin, schließlich ist Linux mit UNIX verwandt, auf dem das Internet damals entwickelt wurde. Hier liegt die Datei unter etc/hosts. Der Aufbau der Dateien ist natürlich identisch, da die Hosts-Datei aus einer Zeit stammt, als es weder Windows noch Linux gab. Daher funktioniert dieser kleine Trick auch unter Linux problemlos (siehe Abbildung 10.5). Auch unter Linux kann man mit dem ping-Befehl die IP-Adressen der Webseiten ermitteln. Allerdings muss man hier die Ausgabe des ping mit (Ctrl)+(C) abbrechen, da sie endlos weiterläuft.

433

10.2

10

Das Netz der Netze

Abbildung 10.5

Die Hosts-Datei unter Ubuntu sieht genauso aus.

»Das Internet ist ein großer Misthaufen, in dem man allerdings auch kleine Schätze und Perlen finden kann.« – Joseph Weizenbaum auf einem Vortrag in Hamburg am 2. Mai 2001, www.heise.de

10.2.4 Webadressen zu verkaufen – InterNIC/ICANN Nachdem aus dem Universitätsnetzwerk ARPANET das Forschungsnetzwerk Internet geworden war und die Knoten unübersehbar wurden, wechselte man von den lokal abgelegten Hosts-Dateien zum sogenannten Domain Name System, abgekürzt DNS. Das DNS-System wurde von einem gewissen Paul Mockapetris 1983 entwickelt. Die Beschreibung findet man im RFC 882 und im RFC 883, das inzwischen durch RFC 1034 und RFC 1035 abgelöst worden ist. Statt festen Einträgen in einer Datei gibt es beim DNS spezielle DNS-NameServer, die ihren Datenbestand automatisch aktualisieren und untereinander abgleichen. Gibt man im URL-Feld des Browsers eine Internetadresse an, so wird diese zunächst einmal aufgelöst, bevor der Betreffende die gewünschte Internetseite senden kann.

434


Der Domainname hat mehrere Bestandteile, die jeweils durch einen Punkt vom vorigen Teil getrennt werden. Ein typischer Domainname wäre beispielsweise www.galileopress.de. Er besteht aus drei Teilen und hat folglich zwei Punkte. Ganz rechts steht die sogenannte Top-Level-Domain; sie steht für die oberste Ebene, etwa das Netzwerk, in dem wir uns befinden. Von diesem Doimainteil gibt es zwei verschiedene Arten: Man unterscheidet zwischen generischen TopLevel-Domains, wie .com, .net, .org oder .info, die man auch mit gTLDs abkürzt, und geografischen Top-Level-Domains, wie .fr, .uk, .us oder .de, die man auch mit ccTLDs abkürzt, wobei cc für Country Code steht. Weiter links steht die Second-Level-Domain, die eventuell für eine Region innerhalb des Landes, eine Firma oder eine Behörde stehen könnte. Als Nächstes folgt links die Third-Level-Domain, meist ist dies schon die Bezeichnung des Protokolls, wie www oder ftp. Es könnte aber auch noch eine Rechnerbezeichnung innerhalb des Firmennetzes folgen, bevor das Protokoll spezifiziert wird. Die Namensauflösung im Internet läuft zunächst über den DNS-Server des Providers zum Root-DNS-Server und von dort über alle DNS-Server bis zu dem DNSServer, der den Namen kennt und die IP-Adresse liefern kann. Praxis: Adresse auflösen Nachdem wir uns die Hosts-Datei so genau angeschaut haben, wollen wir jetzt natürlich auch genau wissen, wie die DNS-Adressauflösung funktioniert. In der Tat gibt es sehr anschauliche Webseiten dazu im Internet. Eine Seite dieser Art ist die folgende: http://www.dnswatch.info. Die Seite hat mehrere Eingabefelder, von denen uns das Feld DNS Lookup / IP lookup interessiert. Hier können wir eine uns bekannte Webadresse eingeben. DNS Watch soll uns anzeigen, wie sich die verschiedenen DNS-Server untereinander so lange austauschen, bis einer der Server die IP-Adresse zu dem Webnamen kennt und zurückmeldet. Verwendet man www.sun.de, erhält man das Ergebnis aus Abbildung 10.6. Man sieht, dass es von einem Root-Servers.net zu einem Server des DENIC geht und wieder zurück. Nach immerhin fünf Zwischenschritten ist als ID-Adresse 137.254.16.52 gefunden. Genauso läuft das ab, wenn man im Browser eine Webseite anfordert. Erst, wenn die IP gefunden ist, wird die eigentliche Seite angefordert und übertragen. Dieses Beispiel ist nicht ganz problemlos, die eigentliche Adresse bei Sun lautet: de.sun.com.

435

10.2

10

Das Netz der Netze

Abbildung 10.6

DNS-Suche nach der IP von Sun

Wenn man wissen möchte, an welcher Stelle der Suche diese Adresse auftaucht, gibt man sie einfach mal bei DNS Watch ein und sieht, dass offenbar der Server de.net die Adresse in die richtige Form bringt. Was aber, wenn man eine nicht existierende URL eingibt? Werden dann alle DNS-Server der Welt abgesucht? Abbildung 10.7 zeigt den Versuch mit der nicht existenten Adresse sukkzz.de.

Abbildung 10.7

436

DNS-Suche nach einer Dummyadresse »www.sukkzz.de«


Wieder wird zuerst beim Root-Server nachgefragt, und dieser reicht die Anfrage an nic.de weiter. Nic.de ist für alle URLs mit dem Suffix .de zuständig. Da er die Adresse nicht findet, wird hier die Suche abgebrochen. Die Verteilung der Adressen: Gründung von InterNIC 1993 fanden sich die National Science Foundation, kurz NSF, und die Firmen AT&T, Network Solutions sowie General Atomics-CERFnet zusammen, um das Problem der Namensvergabe für neue Internetknoten zu lösen. Man kam überein, eine Gesellschaft zu gründen, die kommerziell sein und den Namen InterNIC (Internet Network Information Center) erhalten sollte. Die zugeteilten Aufgaben wurden an die Gründerunternehmen zum »Ausschlachten« weitergereicht. Eine Domainadresse kostete damals 50 $ pro Jahr. Das lukrative Geschäft weckte natürlich Neider, und die Vergabe durch das InterNIC dauerte immer länger, schließlich bis zu 14 Tage. Die Anträge häuften sich mehr und mehr, und die Gesellschaft kam in den Augen der US-Regierung ihrem Auftrag nicht mehr richtig nach. Daher gründeten Verbände aus der Wirtschaft und Wissenschaft im Oktober 1998 die gemeinnützige Gesellschaft ICANN (Internet Corporation for Assigned Names and Numbers). Es wurde beschlossen, die Aufgaben des InterNIC bis Oktober 2000 sukzessive auf die ICANN zu übertragen. Von der InterNIC blieb nicht viel mehr als die Webseite und der geschützte Name übrig. Dieser gehört dem U.S.-Handelsministerium, das Nutzungsrecht wurde jedoch auf die ICANN übertragen. ICANN Die ICANN ist zwar privatrechtlich organisiert, zählt jedoch zu den Non-ProfitFirmen nach US-amerikanischen Recht und hat ihren Sitz in Marina del Rey, einem kalifornischen Ort direkt am Meer bei Los Angeles. Bis zum 30. September 2009 unterstand die ICANN dem amerikanischen Handelsministerium und damit eigentlich der US-Regierung. Seit dem 1. Oktober 2009 untersteht sie einer Art weltweiter Kommission aus Vertretern der Regierungen und Interessengruppen am Internet. Hin und wieder bezeichnet man das ICANN auch als Weltregierung des Internets. Die Hauptaufgaben bestehen darin, dafür zu sorgen, dass IP-Adressen eindeutig sind und die Domainnamen den Konventionen entsprechen. Dazu arbeiten die nationalen NICs mit der ICANN zusammen. Mit ihrer Arbeit verhinderte die ICANN indirekt, dass wirtschaftliche Interessen, z. B. von Konzernen, Zugriff auf die Administration des Internets erhalten. ICANN ist zuständig für die Domains .com, .net, .org, .edu und .us und betreibt auch die dafür nötigen Domain-Nameserver.

437

10.2

10

Das Netz der Netze

Nationale NICs und DENIC Wenn man das Internet als Netz der Netze versteht, kann man die Server mit der Domainendung .de als Teilnetz ansehen. Aufgrund der Vielzahl der Teilnetze und der teilnehmenden Server wurden die Verwaltungsaufgaben für die geografischen Top-Level-Domains an entsprechende lokale Network Information Center übertragen. Das NIC für die deutsche Top-Level-Domain .de nennt sich DENIC. Rechtlich fungiert die DENIC als Genossenschaft. Die Home-Adresse lautet: http://www.denic.de/. Die konkreten Aufgaben der DENIC sind: 왘

Vertretung der nationalen Interessen gegenüber den internationalen Gremien des Internets (beispielsweise ICANN) und Mithilfe bei der weltweiten Koordinierung

왘

Registrierung und Verwaltung der .de-Domainnamen und der Telefonnummern-Domains des 9.4.e164.arpa

왘

Betrieb des deutschen Root-Nameservers für die Verwaltung der Liste aller weltweit ebenfalls von der DENIC betriebenen .de-Domain-Nameserver

왘

Unterstützung bei Fragen und Problemen im Zusammenhang mit den .deDomainnamen

왘

Unterhalten einer Webseite (http://denic.de/) mit Informationen zur DENIC und zu den verwalteten Domains

왘

Erfassen von Streitfällen um .de-Domains per DISPUTE-Einträgen

Auch wenn die Internetnutzung in Deutschland relativ schleppend anlief und die Haushalte lange Zeit prozentual nicht so gut vernetzt waren wie die in Finnland oder Schweden, so hat Deutschland inzwischen doch aufgeholt. Vor allen Dingen bei der Anzahl der .de-Domains kann sich Deutschland sehen lassen. Am 25.3.2010 gab es genau 13.560.536 .de-Domainnamen. Bereits Mitte 2009 wurde die 13-millionste .de-Domain angemeldet. Damit ist die .de-Top-LevelDomain hinter .com und noch vor der chinesischen. Und wie man sieht, kommen jedes Jahr ca. eine Million neue .de-Domains hinzu. Natürlich sind die halbwegs verwendbaren Namen nicht unbegrenzt verfügbar. Daher ist zu erwarten, dass früher oder später die Zahl der Neuanmeldungen zurückgeht. Praxis: Domainabfragen Als deutscher Internetnutzer sollte man wenigstens einmal die Seite der DENIC aufgerufen haben. Zumindest ist sie die letzte Instanz, wenn es darum geht, etwas über eine .de-Domain zu erfahren. Also durchaus ein Grund, diese Seite öfter aufzurufen: http://www.denic.de.

438


Wie bereits erwähnt, bietet die Seite eine ganze Reihe Informationen rund um die Top-Level-Domain .de und zu den technischen Möglichkeiten und Angeboten rund um diese Domain. In der rechten Spalte finden Sie ein Feld, um Abfragen nach Domainnamen abzusetzen. Die Abfrage selbst wird über den Internetdienst whois abgewickelt. Gibt man dort beispielsweise »galileopress« ein, so sollte man ausführliche Informationen über die Domain des Verlages erhalten. Vorher muss man allerdings die Nutzungsbedingungen bestätigen und einen sogenannten Captcha-Test richtig ausfüllen. Wer mit dem Begriff Captcha nicht viel anfangen kann, findet hier eine genaue Erläuterung: http://de.wikipedia.org/wiki/Captcha. Sollten Sie sich dabei vertippen, erscheint die Meldung »Ihre Eingabe war nicht korrekt«. Es könnte aber auch diese ominöse Meldung kommen: »Es existiert keine Session«, was Sie jedoch nicht von einem zweiten Versuch abhalten sollte. Der Test dient dazu, automatische Domainabfragen durch Software zu verhindern. Wenn alles stimmt, sieht man folgende Daten: Domainabfrage-Ergebnis Domaindaten Domain galileopress.de Letzte Aktualisierung 29.05.2009 Domaininhaber Der Domaininhaber ist der Vertragspartner der DENIC und damit der an der Domain materiell Berechtigte. Domaininhaber: Galileo Press GmbH Adresse: Rheinwerkallee 4 PLZ: 53227 Ort: Bonn Land: DE

Auch beim administrativen Ansprechpartner, beim technischen Ansprechpartner und beim Zonenverwalter erscheint die Adresse des Verlages. Zone-C steht dabei für Zone-Contact und zeigt den Zuständigen für die Nameserver innerhalb der Domain. In diesem Zeichen sollst du siegen Kurt A., seines Zeichens selbsternannter Domainbroker, fieberte diesem Tag entgegen: dem 23. Oktober 2009. An diesem Tag sollten endlich ein-, zweistellige und nur aus Zahlen bestehende Second-Level-Domains in Deutschland erlaubt werden. Aus Erfahrung mit dem Kauf und Verkauf von Domains wusste er: Je kürzer und verständlicher ein Domainname ist, umso wertvoller ist er auch.

439

10.2

10

Das Netz der Netze

Um bei dem großen Spiel auch tatkräftig mitspielen zu können, hatte er seinen zwar betagten, aber immerhin noch fahrtauglichen kleinen Sportwagen versetzt. Nun galt es die richtigen Domainnamen zu erstehen, um sie gewinnbringend weiterverkaufen zu können. Was ihm dabei so vorschwebte, war eine Domain wie 123.de oder 6.com. Dass das Kaufen von Domainnamen auf Vorrat, das sogenannte Domaingrabbing, bei seriösen Webanbietern nicht gern gesehen ist, störte ihn dabei wenig. Es wurde ein Tag der Enttäuschungen: Seinen Provider löcherte er mit Telefonaten, doch die Domains, die er sich reservieren lassen wollte, wurden stets mit der lapidaren Meldung abgelehnt, sie seien nicht mehr frei. In der Tat wurde die eine oder andere Domain noch in Versteigerungen angeboten. Doch der Preis schoss so rasant in die Höhe, dass er neben seinem Auto noch ein Haus hätte verkaufen müssen, um den Preis bezahlen zu können. Wer selbst noch eine passende Domain sucht oder sich einmal im Domaingrabbing versuchen möchte, sollte sich auf den Seiten eines Domainhändlers umsehen: http://www.sedo.de/ oder http://www.123domain.eu/. Inzwischen bietet fast jeder Internetprovider Suchfunktionen für Domainnamen an. Dort kann man einen frisch erdachten Webseitennamen eingeben und überprüfen lassen, ob er noch frei ist. Wenn man Genaueres wissen möchte, nutzt man whois oder die Seite des jeweiligen NIC, etwa DENIC. »Das Internet führt am Ende ins Wirrwana.« – Prof. Dr. Hans-Jürgen Quadbeck-Seeger

10.2.5 OpenNIC Wie bei den Betriebssystemen gibt es auch im Internet das Bestreben, die etablierten Strukturen zu unterminieren. Nur hier heißt es nicht Open Sources, sondern OpenNIC. Es handelt sich zwar um ein privatwirtschaftliches NIC, man gibt jedoch an, dass man rein demokratisch verfahre. Um nicht mit den bestehenden TLDs in Konflikt zu geraten, hat man natürlich eigene Bezeichnungen, die gravierend von den üblichen Abkürzungen abweichen, da die Nameserver von OpenNIC nicht über die Nameserver des üblichen Internets erreichbar sind. Die Webseite von OpenNIC ist: http://www.opennicproject.org/. Praxis: Zugang zum OpenNIC Das OpenNIC kann man sich vorstellen wie ein Netz im Netz. Um es »betreten« zu können, muss man einen speziellen Server nutzen, sozusagen als Eingangstür. Diese Zugangs-IP muss in die TCP/IP-Konfiguration eingetragen werden.

440


Unabhängig von der Windows-Version beginnt die Suche nach der Stelle, an der wir den OpenNIC-DNS-Server eintragen, mit Systemsteuerung 폷 Netzwerk- und Freigabecenter 폷 Netzwerkverbindungen verwalten. In dem geöffneten Dialog sehen wir die aktuelle Internetverbindung, unabhängig davon, ob wir per WLAN oder DSL im Internet sind. Klicken Sie mit der rechten Maustaste darauf. Es öffnet sich der Dialog Eigenschaften von... Dieser Dialog enthält eine Liste der installierten Protokolle. Wählen Sie das Internetprotokoll Version 4 (TCP/IPv4) aus. Klicken Sie anschließend auf die Schaltfläche Eigenschaften. Ein weiterer Dialog wird geöffnet, den man über die Schaltfläche Erweitert... verlässt. Nun sehen Sie den Dialog Erweiterte TCP/IP-Einstellungen. Wählen Sie darin den Reiter DNS aus. Tragen Sie jetzt nur noch eine der OpenNIC-IP-Adressen im Feld DNS-Serveradressen... ein, und schon steht Ihnen das Tor zu OpenNIC offen.

Abbildung 10.8

OpenNIC-IP als DNS eintragen

Folgende Zugangsserver ermöglichen den Übergang vom normalen Internet zum OpenNIC: Landeskürzel

IP-Adresse

Server-Webadresse

AU, QLD

58.6.115.42

ns1.qld.au.dns.opennic.glue

AU, QLD

58.6.115.43

ns2.qld.au.dns.opennic.glue

Tabelle 10.1

Zugang zum OpenNIC

441

10.2

10

Das Netz der Netze

Landeskürzel

IP-Adresse

Server-Webadresse

AU, VIC

119.31.230.42

ns1.vic.au.dns.opennic.glue

BR, DF

200.252.98.162

ns1.df.br.dns.opennic.glue

CZ

89.102.101.62

ns1.cz.dns.opennic.glue

DE, BY

81.89.98.6

ns1.by.de.dns.opennic.glue

DE, NI

78.159.101.37

ns1.ni.de.dns.opennic.glue

DE, NRW

217.79.186.148

ns1.nrw.de.dns.opennic.glue

FR

82.229.244.191

ns1.fr.dns.opennic.glue

NZ

203.167.220.153

ns1.nz.dns.opennic.glue

US, CO

216.87.84.211

ns1.co.us.dns.opennic.glue

US, NJ

2001:470:1f07:38b::1

ns1.nj.us.dns.opennic.glue

US, NJ

207.192.69.155

ns2.nj.us.dns.opennic.glue

Tabelle 10.1

Zugang zum OpenNIC

Am sinnvollsten ist es natürlich, eine der drei deutschen IP-Adressen zu nutzen (217.79.186.148, 81.89.98.6 oder 78.159.101.37). Anschließend kann man neben den üblichen Webseiten auch die Webseiten des OpenNIC aufsuchen. Die Vielfalt ist natürlich nicht mit dem Standard des WWW zu vergleichen.

Abbildung 10.9

442

Besuch bei OpenNIC Wiki unter http://wiki.opennic.glue/


Es gibt nicht wirklich viele Seiten unter OpenNIC – aber was nicht ist, kann ja noch werden.

10.2.6 Mit dem Modem in die Mailbox Bevor das WWW in unser Leben trat und uns alle mit dem Internet konfrontierte – das es ja schon lange gab, aber von dessen Möglichkeiten kaum jemand etwas ahnte –, gab es Mailboxen. Wer sich erst in den letzten Jahren mit dem Rechner auseinandergesetzt hat, ahnt kaum noch, was es mit diesen Mailboxen auf sich hatte. Zumal die Online-E-Mail-Clients der großen E-Mail-Anbieter, wie Google Mail und Co., inzwischen auch als Mailboxen bezeichnet werden, was sie im eigentlichen Sinne auch sind. Die Software, die zum Betreiben der Mailboxen diente, nannte sich BBS, was für Bulletin Board System steht. Es handelte sich um Multitasking-Software, die die Eingänge mehrerer Modems oder ISDN-Karten überwachen konnte und den Datenfluss von dort in konkrete Funktionen und Dateiinhalte umsetzen konnte. Im Hintergrund wurde eine Datenbank betrieben, in der die eingehenden und ausgehenden Mails verwaltet wurden, oder man legte sie einfach in einer Verzeichnisstruktur ab. DOS war zu dieser Zeit das vorherrschende Betriebssystem, also musste die Software in der Lage sein, diese Funktionalität ohne große Betriebssystem-Unterstützung allein auf die Beine zu stellen. 1995 erhielt ich vom Bereichsleiter Informatik der Fernschule, bei der ich nebenberuflich tätig war, den Auftrag, eine Mailbox für die Einsendung der Korrekturaufgaben einzurichten. Man hatte erkannt, dass die DFÜ immer mehr an Bedeutung gewinnen würde. Auch sollten die Fernschüler lernen, wie man eine Mailbox nutzt und einrichtet. Es gab die verschiedensten Programme mit unterschiedlichsten Leistungsspektren. Nach intensiver Suche und einigen Probeinstallationen entschied ich mich für die Software Major BBS von Galacticomm. Inzwischen haben sich Liebhaber des Systems zusammengefunden, um alles, was davon geblieben ist, zu sammeln und für die Geschichte der EDV zu konservieren. Die Seite dieser Enthusiasten finden Sie unter http://www.themajorbbs.com/majorbbswiki/display/project/Dashboard. Major BBS konnte unter DOS 256 Nutzer gleichzeitig bedienen, was sehr wichtig war, damit nicht ein Nutzer warten musste, bis der aktuelle Nutzer das System wieder verlassen hatte. Nun gab es erst einmal die Software, aber noch keinen Rechner. Man kam auf die Idee, einen Abrechnungs-PC, der ohnehin nicht ständig genutzt wurde, zum Mailbox-Server aufzurüsten. Natürlich hatte ich in mei-

443

10.2

10

Das Netz der Netze

nem »Homeoffice« bereits alles getestet und per Nullmodemkabel regen Kontakt mit der neuen Schulmailbox gepflegt. So ging die Einrichtung an einem Nachmittag gut von der Hand, und meine Einwahl vom heimischen Rechner zeigte mir, dass alles tadellos lief. Die Software hatte ich so eingerichtet, dass man als Gast auf die Mailbox konnte, um sich selbst anzumelden. Danach ließen sich Nachrichten und Dateien hinterlegen, und anhand der Dateinamen wurden die Einsendungen automatisch dem zuständigen Fernlehrer zugeordnet. An einem kleinen Vorführungstermin wurden die mehr oder weniger betroffenen Mitarbeiter vor Ort mit dem System konfrontiert. Am meisten begeisterte sie das Verzeichnis mit den Spielen, das ich eingerichtet hatte, um reichlich Gäste anzulocken. Die Sache hatte nur einen Haken: Es fanden sich keine Nutzer ein. So blieb ich vorerst der Einzige, der E-Mails ablegte und auch las. Das blieb vorerst so, weil die betreffenden Lehrgänge offiziell noch gar nicht begonnen hatten. So vergingen etliche Wochen, und die Fernlehrer der betreffenden Lehrgänge blieben im BBS unter sich. Bis sich eines Tages die ersten Nutzer einfanden und sich Traffic einstellte. Wir hatten einen der ersten Online-Lehrgänge der Republik. Später wurden es rasch mehr, und die Platte des Servers kleiner und kleiner. Sicherungen auf CD wurden gefahren, und schließlich mussten wir die Doppelnutzung einstellen, um die Online-Studenten nicht einzuschränken. Das System lief problemlos, bis es schließlich durch eine Homepage im Internet ersetzt wurde. Mailboxen dieser alten Art gehören nicht nur zu einer aussterbenden Gattung – sie sind längst ausgestorben. Eine heute noch existierende Mailbox mit umfangreichen Anleitungen finden Sie hier: http://www.tecs.de/.

10.3

Das WWW entsteht

10.3.1 Fragen zu allem und jedem Wie Tim Berners-Lee in seinem Buch über die Geschichte des World Wide Web selbst schreibt, hatte ihn als Kind ein alter Schmöker begeistert. Es war ein alter, verstaubter Foliant aus viktorianischer Zeit. Das, was ihn an dem Buch so fesselte, war das Versprechen, auf jede Frage eine Antwort zu finden. Das Buch trug den Titel »Enquire Within Upon Everything«. Man konnte sich in ein Thema einlesen, und wenn man auf unbekannte Dinge stieß, diese unter ihrem Namen nachschlagen. Es war also eine Art Lexikon für Alltagswissen. Das Buch liegt neben dem Rechner von Tim Berners-Lee, der als erster WWW-Webserver genutzt wurde (siehe Abbildung 10.11).

444

Das WWW entsteht

Abbildung 10.10

Enquire Within Upon Everything von 1865

Von Juni bis Dezember 1980 hatte Berners-Lee als beratender Ingenieur und Consulter zeitweise eine Stelle beim Kernforschungszentrum CERN. Um in der ihm zur Verfügung stehenden kurzen Zeit einen Überblick über sein vielgliedriges Arbeitsumfeld zu bekommen, schrieb er in seiner Freizeit eine Art Expertensystem, dem er den Namen »Enquire« gab. Mit ihm wollte er die Beziehungen zwischen den Projekten, den Mitarbeitern und der Rechnerausstattung festhalten. So entwickelte er eine erste Vorstellung vom Einsatz eines Hypertextsystems. Er träumte davon, Informationen sinnvoll miteinander zu verknüpfen, und das über Computer, ja über alle Grenzen hinweg. Das müsste den Computer in die Lage versetzen, Beziehungen zwischen den Informationen zu nutzen, um den Menschen sinnvoll und selbständig zu unterstützen. Tim Berners-Lee Am 8. Juni 1955 kam Tim Berners-Lee in London als Sohn von Conway Berners-Lee und Mary Lee Woods, zur Welt. Beide Eltern arbeiteten als Mathematiker bei Ferranti, einer britischen Firma für Elektrogeräte, die auch Computer herstellte. Dort waren sie beide an der Entwicklung des Manchester Mark I beteiligt, aus dem der Ferranti Mark I hervorging – nach der Z4 der zweite kommerziell vertriebene Computer der Welt (siehe Kapitel 3, »Vom ersten Computer und anderen Rechnersauriern«). Daher beschäftigte sich Berners-Lee bereits in jungen Jahren mit Computern und machte sich Gedanken über deren Weiterentwicklung.

445

10.3

10

Das Netz der Netze

Nachdem er die Emanuel School in Battersea erfolgreich absolviert hatte, studierte er an der University of Oxford Physik. Am dortigen Queens College erhielt er 1976 sein Diplom. Nach zwei Jahren bei der Plessey Telecommunications Ltd in Poole wechselte er zu D.G Nash Ltd, von wo er auch kurz im CERN arbeitete und seine ersten Überlegungen zum WWW reiften. Von der Nash Ltd wechselte er zur Firma seines Kollegen zur John Poole's Image Computer Systems Ltd, wo er von 81 bis 84 für die Steuerung von Druckern Echtzeitsysteme programmierte und Grafik- und Kommunikationssoftware entwickelte. 1984 bot sich ihm die Möglichkeit, über ein Stipendienprogramm ans CERN zurückzukehren, wo er in der Abteilung für die Datenerfassung und Verarbeitung der Beschleunigerexperimente arbeitete. Hier macht er 1989 den Vorschlag, ein System zu entwickeln, mit dem die Dokumentation und der Informationsaustausch in dem multinationalen Forschungszentrum vereinfacht werden könnte. Damit begann seine Entwicklungsarbeit am World Wide Web, kurz WWW, auf einem Next-Cube-Rechner. 1991 war eine funktionsfähige Version verfügbar. Nachdem Berners-Lee das System bis 1993 weiter verbesserte, gründete er 1994 das World Wide Web Consortium, kurz W3C. Heute lebt BernersLee mit seiner Familie in den USA, in Lexington, Massachusetts. Er ist Professor und Vorsitzender des W3C.

10.3.2 Die Server-Browser-Ehe Berners-Lee hat seine Entwicklung, das Programm »Enquire« beim CERN zurückgelassen, als er es verließ, wo der Code schließlich verloren ging. Die Idee, ein System zu entwickeln, mit dem man Informationen intelligent verknüpfen kann, ließ ihn jedoch nicht los. So stellte er schließlich 1989 den Antrag für ein eigenes Projekt mit diesem Hintergrund. Jedoch erst, als ein neuer Rechner, ein NeXTcube angeschafft und getestet werden sollte, hatte er die klare Anweisung, auf diesem Rechner sein Hypertextsystem zu programmieren. Zugute kam ihm dabei, dass das installierte NextStep ein UNIX-Derivat war und daher das TCP/IPProtokoll unterstützte. Tim Berners-Lee programmierte ein System, bei dem die Daten zentral in den Verzeichnissen eines Servers abgelegt waren. Man konnte aber bei Ansicht der Daten zu anderen Informationen springen, die ebenfalls in den Verzeichnissen des Servers oder irgendeines anderen Servers lagen. Das Wichtigste dabei war die weltweit einzigartige Adresse dieser Datendateien. Berners-Lee erdachte dazu ein System und setze nach diesem die erste Adresse zusammen: info.cern.ch. So wurde dies die erste Adresse der ersten Homepage des neu erstandenen WWW. Neben dem Konzept der Informationsverteilung hatte sich Berners-Lee auch eine Sprache ausgedacht, um die Informationen webtauglich darstellen zu können, die Beschreibungssprache HTML.

446

Das WWW entsteht

Praxis: Wie funktioniert das Internet? Wenn man verstehen möchte, wie das moderne Internet funktioniert, braucht man eigentlich nur zwei Programme zu verstehen: den Server oder, genauer gesagt, den HTTP-Server und den Internet-Browser. Eine Webseite besteht aus einer Reihe von Dateien, die in einem Verzeichnissystem abgelegt sind. Der Webserver hat lediglich die Aufgabe, die erste Datei, die meist index.html heißt, an den Browser zu senden, der mit ihm Kontakt aufgenommen hat. Der Browser empfängt die Datei und stellt sie für den Nutzer lesbar auf dem Monitor dar. Klickt der Nutzer auf einen Link, so steht der für eine weitere Datei. Deren Position wird im Dateisystem dem Server übermittelt, der sie daraufhin hinterherschickt. So geht es fort und fort. Es gibt ein paar Sonderfunktionen auf der Serverseite, wie die Interpretation von serverseitigem Programmcode. Aber mehr ist es wirklich nicht. Inzwischen werden im Grunde alle Dienste, die früher das »nackte« Internet ausmachten, auch per WWW angeboten, also eingepackt in HTML-Seiten. Schauen wir uns die Funktionsweise an zwei ganz einfachen Java-Programmen einmal an. Zunächst lassen wir sie ablaufen, um zu sehen, was sie tun. Sie finden das Serverprogramm unter Software zum Buch\HTTPServer\Miniserver.jar. Gestartet wird es mit java -jar Miniserver.jar

(Der Quellcode liegt als Eclipse-Projekt im gleichen Verzeichnis.) Weiter passiert zunächst einmal gar nicht viel. Es wird lediglich eine Meldung ausgegeben: MiniServer gestartet. Verbindung über Port 88 erwartet.

Was könnte das zu bedeuten haben? Schauen wir uns dazu den Code des kleinen Servers einmal an: package controller; import java.net.*; import java.io.*; public class MiniServer { public static void main(String[] args) { try { ServerSocket servSock = new ServerSocket(88);

447

10.3

10

Das Netz der Netze

System.out.println("MiniServer gestartet. Verbindung über Port 88 erwartet."); Socket sock = servSock.accept(); System.out.println("Connection über Port 88 steht. Streams öffnen."); PrintWriter out = new PrintWriter(sock.getOutputStream()); StringBuffer buffer = new StringBuffer(); InputStreamReader isr = new InputStreamReader( sock.getInputStream(), "UTF8"); Reader in = new BufferedReader(isr); int ch; // Stream belauschen while (buffer.indexOf("\r\n\r\n") == -1) { ch = in.read(); buffer.append((char) ch); } System.out.print(buffer.toString()); if (buffer.indexOf("GET") != -1) { out.print("HTTP/1.0 200 OK\r\n"); out.print("Server: MiniWebServer 0.01\r\n"); out.print("Content-type: text/html\r\n\r\n"); out.print("MiniServer ist wohlauf "); out.flush(); } sock.close(); servSock.close(); System.out.println("Connection zu Port 88 beendet."); } catch (IOException e) { System.err.println(e.toString()); System.exit(1); } } }

Entscheidend sind die Zeilen nach dem try {. Alles davor interessiert uns erst einmal nicht. Hier wird ein Server-Socket für den Port 88 erstellt. Einen Socket kann man sich vorstellen wie eine Steckverbindung. Der Server wird sozusagen

448

Das WWW entsteht

durch diese Zeile mit dem Netzwerk verstöpselt. Er muss nun warten, bis über das Netzwerk Nachrichten kommen. Das bewirkt die übernächste Zeile. Zunächst meldet er sich einmal mit der Nachricht, erfolgreich verstöpselt zu sein. Wir benötigen also ein Programm, das dem Server übers Netzwerk irgendeine Nachricht schickt. Dieses Programm wäre der Browser. Um ihn zu verstehen, haben wir ein kleines Clientprogramm erstellt, das fürs Erste den Browser ersetzen soll. Es nennt sich MiniClient. Das Clientprogramm finden Sie unter Software zum Buch\HTTPServer\Miniclient.jar. Gestartet wird es mit java -jar Miniclient.jar package controller; import import import import import import

java.io.IOException; java.io.InputStream; java.io.OutputStream; java.net.InetAddress; java.net.Socket; java.net.UnknownHostException;

public class MiniClient { public static void main(String[] args) { try { InetAddress address = null; try { adress = InetAddress.getByName("127.0.0.1"); } catch (UnknownHostException e1) { e1.printStackTrace(); } Socket sock = new Socket(address, 88); OutputStream oStream = sock.getOutputStream(); InputStream iStream = sock.getInputStream(); // Das GET-Kommando senden String s = "GET / HTTP/1.0" + "\r\n\r\n"; oStream.write(s.getBytes());

449

10.3

10

Das Netz der Netze

// Ausgabe lesen und anzeigen int len; byte[] b = new byte[100]; while ((len = iStream.read(b)) != -1) { System.out.write(b, 0, len); } // Programm beenden iStream.close(); oStream.close(); sock.close(); } catch (IOException e) { System.err.println(e.toString()); System.exit(1); } } }

Auch bei diesem Programm wird es ab try { interessant. Man sieht: Zunächst wird eine Internetadresse, nämlich die 127.0.0.1, festgelegt. Diese merkwürdige Adresse bezeichnet den aktuellen Rechner. Es ist ein sogenanntes LoopbackDevice. Das kann man sich vorstellen wie an einem CD-Spieler mit Verstärker. Der CD-Spieler erzeugt Musiksignale, die an einen zusätzlichen Verstärker gesandt werden können. Man kann aber auch den Spieler-eigenen Lautsprecher nutzen, sozusagen den Ausgang in den Eingang stecken. Genau das tut 127.0.0.1. Die Adresse nennt man auch Localhost, also »lokalen Hauptrechner«. Mit der Adresse und dem Port 88, der vom Server bewacht wird, erstellen wir ein Socket, also eine Verbindung. Über diese Verbindung senden wir das Wort GET, sozusagen als Nachricht, dass wir etwas vom Server wollen. Versuchen Sie es also einmal mit dem Start der MiniClient-Anwendung: Software zum Buch\ HTTPServer\Miniclient.jar. Gestartet wird es mit java -jar Miniclient.jar

(Der Quellcode liegt als Eclipse-Projekt im gleichen Verzeichnis.) Falls nicht zufällig der Miniserver läuft, passiert rein gar nichts. Es wird nur diese Meldung ausgegeben: Java.net.ConnectionException: Connection refused: connect

Was so viel heißt wie »es konnte keine Verbindung aufgebaut werden«.

450

Das WWW entsteht

Nun starten wir zuerst den Server und dann den Client in einer eigenen Konsole. Auf beiden Konsolen erhalten wir nun Meldungen: MiniServer gestartet. Verbindung über Port 88 erwartet. Connection über Port 88 steht. Streams öffnen. GET / HTTP/1.0 Connection zu Port 88 beendet.

Das erzählt uns der Server, er hat also nicht umsonst gewartet. Eine Verbindung über 88 wurde genutzt und die Meldung GET / HTTP/1.0 empfangen, danach hat sich der Server beendet. Der Client meldet: HTTP/1.0 200 OK Server: MiniWebServer 0.01 Content-type: application/octet-stream MiniServer ist wohlauf

Er hat also vom Server eine Antwort erhalten. Wichtig ist es zu berücksichtigen, dass sich der Server nach Erhalt und Abarbeitung immer beendet, also wieder neu gestartet werden muss. Versuchen wir das Ganze nun mit einem Browser. Dazu müssen wir den Server allerdings erst noch einmal starten. Nun geben wir in unserem Lieblingsbrowser ein: http://localhost:88

Auch dieses Mal meldet sich der Server freundlich zurück. Wenn wir uns das im Code ansehen, stellen wir fest, dass es diese Zeile ist: out.print("MiniServer ist wohlauf");

Das ist genau die Stelle, an der ein Webserver üblicherweise eine HTML-Datei überträgt. Wer sich schon ein wenig auskennt, hat sofort erkannt, dass diese Zeile HTML enthält, die Sprache, in der Webseiten beschrieben sind. »Internet macht impotent. Früher hatte ich Hardware, heute habe ich nur noch Software.« – Rudi Carrell Anmerkung des Verfassers: Offenbar sah er die Entwicklung des Cloud Computing voraus.

451

10.3

Das Netz der Netze

10.4

Browser

Nach zögerlichen Anfängen begannen die Benutzer das System von Berners-Lee zu verwenden. Er hatte den Rechner, an dem er HTML und das WWW entwickelte (es war ein NeXTcube), als Webserver eingerichtet. Sein Arbeitsplatzrechner war damit zum ersten Webserver der Welt geworden.

© Coolcaesar; http://commons.wikimedia.org/

10

Abbildung 10.11 Berners-Lees NeXTcube im CERN-Museum mit einem Exemplar des »Enquire Within Upon Everything«

Die Idee, dass jedermann nicht nur die Informationen einsehen, sondern auch selbst einstellen könnte, ließ sich nicht so einfach verwirklichen, wie sich Berners-Lee das dachte. Dazu benötigte man zunächst einmal einen HTML-Editor, und die erstellten Seiten mussten auf dem Server abgelegt werden. Das geschah damals, wie es auch noch heute gehandhabt wird, mit FTP. Alles Dinge, die sich vielleicht ein Informatiker zutraute, doch Atomphysiker hatten dazu oft keinen Draht und nutzten das entstehende Minimal-WWW vorrangig als Informationsquelle (siehe Abbildung 10.12). Nachdem das Web im CERN erst einmal lief, kam es darauf an, für die verschiedenen Rechner, die in dem großen Institut genutzt wurden, Browser zu schreiben. Da die Gruppe um Lee genug damit zu tun hatte, das Web in Gang zu halten, kam die Weiterentwicklung an dieser Stelle schon recht früh ins Stocken. Zum Glück war das WWW von Anfang an offen konzipiert. So war das Interesse an dem neuen System außerhalb des CERN bald größer als beim CERN selbst. Nach und nach waren für jeden Rechnertyp Browser verfügbar.

452

Browser

Abbildung 10.12

Lees erste Webseite sah so aus.

10.4.1 Der Luchs machte den Anfang Einer der ersten Browser, die Tim Berners-Lee von Externen programmiert bekam, war Lynx. Er war bereits vor Entwicklung des WWW für ein Hypertext-System entwickelt worden. Studenten hatten ihn 1992 an der Universität von Kansas für das WWW umgebaut. Lynx (Englisch für »Luchs«) ist rein textorientiert, kann also keine Grafiken anzeigen, stattdessen zeigt er die alternativen Textnamen. Er kann deshalb auch ohne Maus genutzt werden. Trotz seiner tristen Art ist er für fast für alle Betriebssysteme erhältlich. In Linux ist er ohnehin verfügbar und kann leicht mit Hilfe der jeweiligen Paketverwaltung nachinstalliert werden (siehe Abbildung 10.13). 453

10.4

Das Netz der Netze

Abbildung 10.13

Google im Lynx-Browser

Natürlich gibt es Lynx auch für Windows und sogar für DOS. Wer es sich ansehen möchte, findet die entsprechende Software über http://pachome1.pacific. net.sg/~kennethkwok/lynx/. Berners-Lee hatte zur Vorführung seiner Idee ein Browser-Programm entwickelt, das er aufschneiderisch World Wide Web taufte, obwohl sich seine Idee kaum über die Grenzen des CERN herumgesprochen hatte. Später wurde der Browser in Nexus umgetauft – wahrscheinlich, weil er ihn auf seinem NeXTcube entwickelt hatte. Doch Nexus hatte noch seine Schwächen.

© Ragib Hasan; http://de.wikimedia.org/

10

Abbildung 10.14

454

Gedenktafel für den Mosaic, den ersten grafischen Webbrowser

Browser

Deshalb bedeutete die Einführung des Lynx im CERN trotz seiner Einfachheit bereits einen großen Fortschritt für die Weiterentwicklung des WWW. An den amerikanischen Forschungseinrichtungen registrierte man vielleicht noch rascher als in Europa, wie umwälzend neu die Idee des WWW war. So wunderte sich Berners-Lee nicht, dass der nächste Browser aus Amerika kam, und zwar vom NCSA, dem National Center for Supercomputing Applications an der Universität von Illinois (siehe Abbildung 10.14). Die Leitung des Entwicklungsteams lag in der Hand von Marc Andreessen und Eric Bina. Sie nannten ihr Produkt Mosaic, weil es als erster Browser die Bilder einer Webseite automatisch lud, ohne dass man sie per Klick anforderte (siehe Abbildung 10.15), so dass die Seiten manchmal wie ein Patchwork-Bild wirkten. Entwickelt hatte man den Browser 1992, 1993 wurde die Firma Spyglass für den Verkauf gewonnen. Microsoft erwarb bereits 1994 eine Generallizenz für zwei Millionen Dollar. Entsprechend dem Vertrag mussten sie außerdem für jede verkaufte Kopie 98 Cent zahlen. Ein Jahr später lieferte Microsoft erstmals im Paket Microsoft Plus den Browser Internet Explorer für Windows 95 aus. Bis 2008 enthielt der Microsoft Internet Explorer den Hinweis »basiert auf NCSA Mosaic«.

Abbildung 10.15

Mosaic Version 2.11 mit einer Webseite des Servers »WebSite« von O’Reilly

455

10.4

10

Das Netz der Netze

10.4.2 Der Browserkrieg Für einige Jahre war Mosaic gleichbedeutend mit dem Begriff Browser, so dass ihn auch andere Firmen für ihr Browser-Produkt nutzten. Sein Entwickler, Marc Andreessen, verließ 1994 das NCSA-Team, um die Firma Netscape zu gründen, die in den folgenden Jahren mit ihrem Browser IT-Geschichte schreiben sollte. Mosaic wurde 1997 mit der Version 3.0 eingestellt.

Abbildung 10.16

Der Netscape mit der gleichen Webseite

Der Netscape Navigator, wie Andreessen sein Produkt nannte, eroberte den Browser-Markt im Sturm. Nach zwei Jahren sah es aus, als gäbe es bald nur noch einen Internetbrowser (siehe Abbildung 10.17).

Abbildung 10.17

456

Der Marktanteil des Netscape Browsers

Browser

Aus Furcht, seinen Platz in diesem doch zukunftsträchtigen Markt zu verlieren, zettelte Microsoft den sogenannten »Browserkrieg« an. Angst machte sich breit. Brad Silverberg, der damals bei Microsoft arbeitete, formulierte es später so: »Wir liefen Gefahr, durch den technischen Fortschritt bedeutungslos zu werden.« Windows war das meistverkaufte Betriebssystem, so brauchte Microsoft seinen Browser nur mit Windows mitzuliefern, um ihn weit zu verbreiten. Außerdem verhinderte man durch Verheimlichen wichtiger Windows-Interna, dass die konkurrierenden Browser, vor allem Netscape, schneller arbeiten konnten als der Internet Explorer. Diese Marktmacht führte dazu, dass der Anteil des Explorers sich stetig erhöhte, und das, obwohl er viel fehlerhafter lief als die Konkurrenz und in manchen Versionen sogar wesentlich langsamer war. Schließlich sank der Marktanteil des Netscape auf unter vier Prozent ab. Netscape wusste sich keinen anderen Rat mehr, als den Quellcode des Browsers unter die Open-Source-Lizenz zu stellen, ihn also zu veröffentlichen und freizugeben. Während AOL die Firma Netscape 1998 für 4,2 Milliarden $ kaufte, entwickelte die Open-Source-Gemeinschaft den Mozilla als Konkurrenten zum Internet Explorer. Der Name sollte noch einmal an den legendären Mosaic erinnern. Aus Mozilla wurde schließlich Firefox, der heute noch gerne genutzt wird. 2008 gab AOL bekannt, dass die Unterstützung des Netscape Navigators eingestellt wurde.

Abbildung 10.18

Netscape Gold Browser – Version 1996

457

10.4

10

Das Netz der Netze

Trotz Browserkrieg etablierten sich während dieser Zeit viele neue Internetvisualisierungs-Programme am Markt, man denke nur an Namen wie Opera, Chrome (Google) und Safari (Apple). Heute dominieren nur noch zwei Browser den Markt: ganz vorn der Internet Explorer (62 %), der noch immer deshalb führend ist, weil er mit Windows mitinstalliert werden kann, und der Firefox (30 %). Doch der Browserkrieg ist noch nicht zu Ende, wenn auch Waffenstillstand herrscht. Es gilt die Meinung, wer den Browsermarkt beherrscht, beherrscht in wenigen Jahren die gesamte IT, denn der Browser wird die kommende Arbeitsoberfläche sein und womöglich Betriebssysteme völlig verdrängen. Doch dazu später mehr (siehe Kapitel 12, »Mein PC is’ ene Wolke«). Wenn man sich in Erinnerung ruft, mit welchen Ideen Tim Berners-Lee damals beim CERN sein Programm »Enquire« schrieb, braucht man sich nicht zu wundern, dass der Vater des WWW mit seinem »Kind« nicht zufrieden war. Er wollte nicht nur Informationen von Wenigen zur Verfügung stellen, sondern eine umfassende Kommunikationsplattform schaffen – von allen für alle. Annähernd ist es das natürlich schon, das WWW, aber eben doch nicht ganz. Deshalb hat er sich im WWW Consortium, dessen Vorsitzender er ist, ständig bemüht, das Internet weiterzuentwickeln. Das, was dabei herauskommen soll, bezeichnet man heute als das semantische Web.

10.5

Das semantische Web

RDF oder Resource Description Framework heißt die Lösung für dieses neue Web. Damit Rechner mit Daten in Form von Bildern, Wörtern und Texten umgehen können, müssen sie vor allen Dingen wissen, um was es sich jeweils handelt. Ein Browser muss schließlich die ankommenden Daten mit dem richtigen Hilfsprogramm anzeigen: Filme mit einem AVI-Player, Sound mit einem Soundplayer und Bilder als Grafiken. Inzwischen werden weit mehr verschiedene Dateitypen im Internet hin- und hergeschoben, als ich hier aufgezählt habe. Und darüber hinaus muss ein moderner Browser teilweise auch verstehen, was in der jeweiligen Datei für Informationen stecken. Wenn ein Film die Größe 512 x 218 hat, sollte er ihn auch nicht viel kleiner anzeigen, es sei denn, der Nutzer möchte das so. Aber es gibt bereits viel komplexere Bezüge innerhalb der Daten, die durch das Internet wandern. Dies alles beschreibt man durch RDF, was ganz neue Möglichkeiten eröffnet. Man kann bestimmte Bereiche aus Webseiten herausnehmen und zu eigenen Seiten zusammenstellen. Die Möglichkeiten sind heute noch gar nicht völlig ausgeschöpft, und die Techniken sind im raschen Wandel begriffen.

458

Das semantische Web

Es zeigt sich bisher, dass wohl XML eine große Rolle bei der Beschreibung der semantischen Sachverhalte spielen wird. Im Zusammenhang mit dem semantischen Web fällt auch immer der Name Web 2.0, der die Weiterentwicklung des Web symbolisieren soll. Tim Berners-Lee selbst gefällt dieser Ausdruck nicht. Seiner Meinung nach enthält er keine konkrete Aussage. Eine genauere Beschreibung zum RDF finden Sie unter http://de.wikipedia.org/wiki/Resource_ Description_Framework. Praxis I: Feedly In der Tat sind die Neuentwicklungen im WWW im Rahmen des Web 2.0 schwer zu überblicken. Eine bessere Vorstellung davon bekommt man, wenn man es praktisch nutzt. Um das neue Web in Aktion zu erleben, wenden wir Feedly von DevHD Streets an, eine Webseite, die die neuen Möglichkeiten intensiv nutzt. Hatten Sie nicht auch schon einmal den Wunsch, von allen Seiten, die Sie vielleicht tagtäglich durchblättern, nur das angezeigt zu bekommen, was Sie wirklich interessiert? Genau das macht Feedly möglich. Die Webseite des Anbieters ist www.feedly.com. Nach der Anwahl bekommt man zunächst einmal die Chance, Get feedly for Firefox zu installieren. Für andere Browser ist Feedly leider nicht verfügbar. Wer Firefox nicht installieren möchte, hat vielleicht Interesse an Flock, das im nächsten Abschnitt beschrieben wird. In dem folgenden Schritt wird man aufgefordert, ein Google-Konto einzurichten. Es dient als Zugang zu dem eingerichteten Feedly-Account. Hinterher nimmt man Source(Quell)-Seiten auf, oder man nutzt direkt ein RSS-Feed. Den Link dazu finden Sie ganz oben rechts: add source. Unter organize sources können Sie die Quellen gruppieren und auf den Seiten, die Sie sich erstellen, anordnen. Dazu lassen sich eigene Kategorien anlegen. Man kann sich aber auch an den vorgegebenen orientieren wie: 왘

Cover

왘

Digest

왘

Latest

왘

Popular

Am Ende haben Sie eine individuelle Seite, die übersichtlich das anzeigt, was Sie im Moment interessiert. Vor allen Dingen können Sie jeden Teilbereich der Seite sich separat aktualisieren lassen, was sehr effektiv ist. Aber was am besten ist, ist das, was nicht da ist: Werbung.

459

10.5

10

Das Netz der Netze

Abbildung 10.19

Individuelle Seiten mit dem Web 2.0

Praxis II: Flock Man findet Flock im Internet unter http://flock.com/. Er wird wie ein üblicher Browser installiert, wenn er auch etwas anders aussieht. Am auffälligsten ist die Seitenleiste rechts, in der man Facebook, Twitter und Flickr aktivieren kann. Mit dem Import-Link lassen sich die Favoriten von anderen Browsern auf dem Rechner übernehmen, wobei Flock die Favoriten etwas vorteilhafter auf einer Art Webseite anzeigt. Überhaupt ist Ordnung die größte Stärke von Flock. Nicht nur, dass die History ständig protokolliert, wo man beim täglichen Surfen überall verweilt – das macht eigentlich jeder Browser in seinem Cache. Wenn man auf das Icon Flock anpassen klickt (das Icon in Form einer Tabellenspalte oben rechts), bekommt man das Hauptmenü zu sehen. Es enthält eine ganze Reihe von Funktionen, unter anderem auch Verlauf. Dort lässt sich sehr übersichtlich mit Tag und Uhrzeit nachvollziehen, welche Seite man sich angeschaut hat. Wem die Funktionen dieses Menüs nicht genügen, der kann Flock beliebig erweitern. Da Flock auf Google’s Chrome aufbaut, können beliebig Erweiterungen aus der Palette der Chrome-Erweiterungen installiert werden.

460

Lesen Sie weiter

Abbildung 10.20

Flock schafft Ordnung in der Wolke mit Web 2.0.

Entwicklung mit Weitblick Neben dem Wunsch, Information überall verfügbar zu machen, stand am Ziel der Internetentwicklung von Anfang an bereits eine andere Idee. Nämlich die Idee, den Computer selbst, seine Rechenleistung unabhängig vom Standort verfügbar zu haben. Diese Idee scheint heute fast verwirklicht, und die Technik dazu nennt sich Cloud Computing. Doch dazu mehr in Kapitel 12, »Mein PC is’ ene Wolke«. »Als das Internet erfunden war, begann man sich Gedanken darüber zu machen, wofür man Computer überhaupt gebrauchen kann.« – Aus einer Tageszeitung

10.6

Lesen Sie weiter


Beschreibung

http://de.wikipedia.org/wiki/Geschichte_ des_Internets

Wikipedia zur Internetgeschichte

http://www.daniel-von-der-helm.com/ internet/entwicklung-des-internet.html

Geschichte des Internets

461

10.6

10

Das Netz der Netze

URL

Beschreibung

http://www.asciizeichen.de/tabelle.html

die Zeichencodetabelle

http://www.darpa.mil/

Darpa-Homepage

http://www.technovelgy.com/ct/ Technology-Article.asp?ArtNum=59

Darpa-Projekte

http://www.kossakowski.de/kap222.htm

der erste Computerwurm

http://www.archive.org/web/web.php

Webseiten-Archiv

http://info.cern.ch/NextBrowser1.html

Tim Berners-Lees Browser von 1993

http://infotekten.de/index.php?itemid=308 das Internet einfach erklärt http://www.w3.org/History/19921103Kopie der ersten Webseite von 1992 hypertext/hypertext/WWW/TheProject.html http://www.michaelkaul.de/Geschichte/ geschichte.html

Geschichte des Internets

http://www.w3.org/People/Berners-Lee/ Longer.html

Lebenslauf von Tim Berners-Lee beim W3C

http://www.dnswatch.info

DNS-Serversuche

http://www.w3.org/

das World Wide Web Consortium

http://www.sedo.de/

Domainhandel

http://www.opennicproject.org/

OpenNIC-Seite

http://www.denic.de/

DENIC-Seite

http://lynx.browser.org/

Lynx-Homepage

http://www.mozilla-europe.org/de/firefox/

Firefox-Homepage

http://www.opera.com/

Opera-Webbrowser

http://www.apple.com/de/safari/ download/

Apple-Safari-Seite

http://www.google.com/chrome

Google Chrome

http://www.feedly.com/home#my

Feedly-Homepage

http://flock.com/

der Web 2.0-Browser Flock

462

TEIL III Die Zukunft

»Die Schreibmaschine wurde vom Computer abgelöst. Ich möchte gar nicht wissen, von was der Computer einmal abgelöst wird.« – Hans-Joachim Kulenkampff

»Die Zukunft wird dank des Computers sicher sicherer werden. Ohne wäre sie in jedem Fall sicherer.« – Anonymus

»Es kann sein, dass wir uns in 50 Jahren gar keine Computer mehr kaufen müssen. Die Menschen, die es dann gibt, werden von Computern gekauft worden sein.« – Anonymus

»Nur ein Programm, das niemand braucht, läuft fehlerfrei!« – Murphy Ein neuer Rechner wäre doch ganz gut, um gefahrlos alles zu installieren, was auf der DVD beigelegt ist? Nichts einfacher als das. Ein Stück Software zaubert uns so viele Rechner, wie wir wollen. Wenn es sein muss, ein halbes Dutzend.

11

Virtualisierung

1974

1993

1998 1999

2002 2003

2007

Speichervirtualisierung Wine VMware erste virtuelle PCs Virtual PC XEN Virtual BOX

11.1

Ein Rechner zum Experimentieren

Ob Windows oder Windows Vista, Linux oder Mac OS X – das Betriebssystem, seine Installation und Anpassung ist eine langwierige und knifflige Angelegenheit. So knifflig, dass sich viele inzwischen einen Rechner kaufen, der fertig installiert ist, und diese Installation, solange sie den Rechner nutzen, nie mehr ändern.

465

11

Virtualisierung

Nun wäre es aber sinnvoll, wenn wir zu diesem oder jenem Thema DOS installieren könnten oder vielleicht Ubuntu. Außerdem birgt die Installation von Software immer die Gefahr, sich einen Computervirus einzufangen. Auch dagegen sollte man Schutzmaßnahmen ergreifen. Alles Dinge, die viel Zeit und Aufwand kosten. Es gibt jedoch eine Möglichkeit, sich an dieser Stelle das Leben einfacher zu machen. Sie nennt sich Virtualisierung. In vielen Unternehmen wird sie bereits von den Systemadministratoren genutzt. Auch wenn es darum geht, zahlreichen Nutzern sauber konfigurierte Rechner zur Verfügung zu stellen, kann Virtualisierung sehr sinnvoll sein.

11.1.1

Das Grundprinzip

Virtualisierung auf unserem heimischen PC bedeutet, dass wir eine Software installieren, die sich gegenüber einem Betriebssystem so verhält, als sei sie ein eigenständiger Rechner. Wenn wir sie starten, sehen wir einen Dialog, der die Monitoroberfläche unseres virtuellen Rechners zeigt. Booten wir den Rechner, startet er das installierte Betriebssystem und darauf die installierte Anwendersoftware, und zwar ganz so, als sei sie ein selbständiger Rechner. Und das Ganze nicht ein- oder zweimal, sondern so oft wir wollen – Hardware aus Software sozusagen. Auf einem Hostsystem (auch Wirtssystem), dem realen Rechner, werden per Software weitere Rechner simuliert, auch Gastsysteme genannt. Wirtssystem Einen Rechner, auf dem Virtualisierungssoftware läuft, mit der wenigstens ein weiterer Rechner simuliert wird, nennt man Wirt oder Wirtssystem.

Gastsystem Einen mit einem Betriebssystem versehenen virtuellen Rechner bezeichnet man zur Unterscheidung vom realen Rechner, auf dem er läuft, als Gast oder Gastrechner.

Diese neuen Rechner können natürlich nicht so schnell und auch nicht so leistungsfähig sein wie ein richtiger PC, aber sie haben dafür eine Reihe anderer Vorteile, die hier kurz genannt sein sollen: 왘

Verfügbarkeit mehrerer Betriebssysteme ohne Zusatzaufwand und synchron auf einem Rechner

왘

bessere Ausschöpfung der Rechnerleistung des Wirtsrechners

왘

Wirtssystem weiterhin unabhängig nutzbar, also »wie vorher«

466


왘

Einrichten neuer Rechner, ohne zusätzliche Hardware anschaffen zu müssen

왘

Verwendung älterer Software auf einem modernen Rechner ohne Umkonfigurierung

왘

Stoppen, »Einfrieren« eines Rechners möglich, um später genau dort weiterzuarbeiten, wo man aufgehört hat

왘

Simulation ganzer Netzwerke im Hauptspeicher eines Rechners

Umfassend lässt sich die Virtualisierung natürlich nicht in einem Kapitel abhandeln. Außerdem ist sie in unserem Fall nur Mittel zum Zweck. Um die Geschichte des Computers praktisch nachzuvollziehen, ist es sinnvoll, wenn man Computer mit älterer Software ausstatten kann, ohne den heimischen PC gleich ganz umrüsten zu müssen. Schließlich wollen wir uns mit Computern, ihren interessantesten Betriebssystemen und toller Software befassen. Dabei hilft uns eine der modernsten Techniken der EDV, die Rechnervirtualisierung, die auch ein Teil der Informatikgeschichte ist, wenn auch ein recht junger. Das verhindert eine Zerstörung bestehender Konfigurationen und erlaubt uns, andere Betriebssysteme zu installieren, ohne die bestehende Konfiguration zu überschreiben. Selbst wenn Sie noch nie einen Rechner konfiguriert haben, können Sie das mit Hilfe virtueller Computer bewältigen, also keine Angst. Im zweiten Teil des Kapitels werden wir uns die Virtualisierungssoftware ansehen und installieren. Vorher gibt es noch Informationen für die ganz Wissbegierigen, und zwar tiefergehende Details zur Virtualisierung.

11.1.2

Sinn und Zweck der Virtualisierung

Virtualisierung, ein im Grunde recht neuer Zweig in der praktischen Informatik, ist längst zum Schlagwort geworden. Was den EDV-Verantwortlichen dabei vorschwebt, sind zwei Dinge: Einmal möchte man die Pflege der zahllosen Rechner eines Büros vereinfacht wissen, zum anderen soll die Rechenleistung der PCs besser ausgenutzt werden, ohne dass der Nutzer sie irgendwie für fremde Zwecke missbrauchen kann (Spiele o.Ä.). Ein weiteres Ziel ist, am Arbeitsplatz nicht ständig das neueste PCModell nachrüsten zu müssen. Billige Net-Computer ohne Festplatte tun es auch. Um das zu erreichen, bleibt der persönliche PC zwar nach wie vor neben dem Schreibtisch stehen, aber das Betriebssystem und die Software laufen auf einer Simulation und werden übers Netz zur Verfügung gestellt.

467

11.1

11

Virtualisierung

11.1.3

Wie funktioniert das genau?

Dem Betriebssystem wird – versteckt – eine sogenannte Abstraktionsschicht untergeschoben, die es von der eigentlichen Hardware, dem Rechner mit seiner Rechenleistung und dem Speicherplatz, softwaretechnisch trennt. Der Nutzer arbeitet an einem Betriebssystem, das sich verhält, als liefe es auf echter Hardware; diese wird ihm jedoch von der virtuellen Maschine, der Virtualisierungssoftware, nur vorgegaukelt. Die Virtualisierungssoftware hat die Aufgabe, die echte Hardware – soweit vom jeweiligen Betriebssystem benötigt – so zur Verfügung zu stellen, dass das Gastsystem den Eindruck hat, es laufe auf einem Rechner, der nur für es da ist. Das ist nicht ganz einfach, schließlich liegt zwischen der Hardware und der Virtualisierungssoftware noch das andere, das Wirts-Betriebssystem. Das lässt sich mehrfach durchführen, und somit kann man verschiedene Betriebssysteme gleichzeitig auf einem Rechner laufen lassen (siehe Abbildung 11.1).

Gast

Gast

Gast

Gast

DOS

LINUX

Windows

OS/2

Virtualisierungssoftware Betriebssystem Hardware Abbildung 11.1

Schematische Darstellung der Virtualisierung

In der Virtualisierung unterscheidet man prinzipiell Emulation und Simulation. Stellen Sie sich einen Windows-Rechner vor und ein Linux-Programm. Nun gibt es zwei Möglichkeiten für das Windows-System, dieses fremde Programm auszuführen. 왘

Erste Lösung: Ein Programm »rechnet« die Linux-Befehle des Linux-Programms »um«, so dass sie von Windows als Windows-Befehle ausgeführt werden können.

왘

Zweite Lösung: Die zweite Möglichkeit ist, dem Linux-Programm »vorzugaukeln«, da sei gar kein Windows, sondern ein vollwertiger Rechner, auf dem Linux installiert ist. Die Software läuft also im Endeffekt auf einem LinuxRechner, auch wenn dieser sozusagen nur aus Software besteht.

468


Die zweite Möglichkeit wird heute zur Virtualisierung verwendet. Anstatt der Software das erforderliche Betriebssystem vorzugaukeln, macht man einfach dem Betriebssystem vor, es handele sich um den notwendigen Rechner, installiert schließlich das Betriebssystem mitsamt allen gewünschten Programmen und führt dann die Programme aus. So lässt sich dem Betriebssystem sogar Hardware vorgaukeln, die gar nicht vorhanden ist. Insbesondere der Marktführer VMware bringt die Virtualisierung durch die Entwicklung neuer Produkte rasch voran. Von ihm gibt es einen Player, der virtuelle Rechner lediglich abspielt, ohne dass man sie konfigurieren kann. Es gibt sogenannte Virtual Appliances, also virtuelle Anwendungen, die man nur starten muss, um sie von VMware ausführen zu lassen. Es ist allerdings ungünstig, zunächst ein Betriebssystem auf einem Rechner zu installieren, um darauf eine VM-Software zu installieren, auf der im virtuellen Rechner wieder ein Betriebssystem eingerichtet wird. Interessanter ist es, ohne Betriebssystem direkt eine Virtualisierungssoftware zu installieren, auf der die Betriebssysteme eingerichtet werden. Diesen Weg beschreitet Xen. Da es unterhalb der Betriebssystem-Ebene sitzt und die Hardware direkt anspricht statt sie per Software zu emulieren, ist es schneller als die herkömmlichen virtuellen Systeme. Und das unter anderem auch, weil neuere Prozessorarchitekturen (Intel VT-x – Vanderpool, AMD Pacifica) diese Art der Virtualisierung direkt unterstützen. Sie sind allerdings noch nicht ganz so etabliert wie die Virtualisierungssoftware von VMware. Auch im Bereich der Programmiersprachen geht es um virtuelle Maschinen, z. B. bei Java. In gewisser Weise wird dort auch eine Art Rechner simuliert, auf dem das Java-Programm ausgeführt wird. Das bewirkt die sogenannte Systemunabhängigkeit. Die virtuelle Maschine stellt für die Sprache Java immer den gleichen Rechner dar, ob sie nun auf einem Windows-Rechner, auf einem Sun-System, einem Apple oder auf einem Linux-Rechner läuft. Trotzdem ist es natürlich nicht die gleiche Technik wie bei der Virtualisierung per VMware oder Xen. Selbstverständlich gibt es auch Kritiker dieser Technologie. Sie sind der Meinung, dass ein gutes Betriebssystem virtuelle Techniken überflüssig machen müsste.

11.1.4

Die wichtigsten Anbieter

Im Moment gibt es zwei Marktführer, drei wichtige und zahlreiche kleinere Anbieter. Da ist einmal der Platzhirsch VMware, der sich durch langjährige Erfahrung ein festes Standbein in diesem Bereich erworben hat. Daneben hat sich Microsoft durch die Übernahme der Firma Connectix mit Virtual PC einen Platz im Markt gesichert. Etwas weniger weit verbreitet, aber dafür Open Source

469

11.1

11

Virtualisierung

ist VirtualBox von Sun/Oracle und Qemu, ein Open-Source-Projekt unter Linux. Außerdem gibt es noch Parallels Desktop in der Apple-Welt. VirtualBox Obwohl von der deutschen Firma Innotek entwickelt, die von Sun aufgekauft worden ist, das wiederum von Oracle übernommen wurde, sind alle Unterlagen in Englisch. Das Produkt bietet Rechner für zahlreiche Betriebssysteme und läuft sehr stabil, benötigt allerdings relativ viel Systemressourcen. Qemu Qemu ist ein noch relativ junges Open-Source-Projekt – von Mitte 2006, die aktuelle Version ist 0.12.5 –, aber dennoch bereits eine sehr stabile und leistungsfähige Virtualisierungssoftware. Für den Linux-Nutzer lohnt es sich in jedem Fall, sich dieses Produkt einmal anzusehen. Virtual PC Das Produkt von Microsoft heißt Virtual PC und liegt in einer kostenlosen Version für 32- und 64-Bit-Rechner vor. Simuliert werden jedoch nur 32-Bit-Maschinen. VMware VMware bietet gleich eine ganze Palette von Produkten, um Rechner zu virtualisieren: 왘

VMware ESXi Server: kostenlose VMware-Serverversion zum Testen dieser Technik

왘

VMware View: Desktop-Virtualisierung und Cloud Computing

왘

VMware vCenter Converter: wandelt eine bestehende Rechnerinstallation in einen virtuellen Rechner um

왘

VMware Player: Abspielprogramm für virtuelle Rechner, unabhängig vom GSX-Server

Xen Vor allem bei Xen spricht man von einem sogenannten Virtuellen MaschinenMonitor (VMM). Xen wird vorrangig an der Universität Cambridge entwickelt, obwohl es der GPL unterstellt ist. Inzwischen hat man ein Unternehmen gegründet, XenSource, das die Vermarktung übernimmt.

470


Xen nutzt ein etwas anderes Prinzip als die übrigen VMMs. Anstatt ganze Rechner zu simulieren, reicht es die Hardwarezugriffe der Gast-Betriebssysteme direkt an die Hardware weiter. Das führt dazu, dass die Gastsysteme fast so schnell laufen, als seien sie direkt auf der Hardware installiert. Praxis: Virtuelles System auswählen Genug der grauen Theorie. Fangen wir einfach an, eines dieser tollen virtuellen Systeme auszuprobieren. Im Anhang A, »VirtualBox«, wird die Installation und Bedienung eines der gängigsten Systeme beschrieben. Was nicht bedeutet, dass Sie nur dieses System nutzen sollen. Aber was Sie tun sollten, ist, in jedem Fall einen virtuellen Rechner zu nutzen, wenn Sie die Experimente aus diesem Buch nachvollziehen wollen. Die einzelnen virtuellen Systeme laufen nicht auf jeder Hardware, auch nicht gleich gut, so dass Sie sich gegebenenfalls umsehen sollten, um das optimale System für Ihre Hardware zu finden. Auf der DVD befindet sich das VirtualBox-System von Oracle/Sun in verschiedenen Versionen und außerdem eine ältere Qemu-Version. Es liegen einige ältere Versionen von VirtualBox auf der DVD bereit, weil ältere Software unter Umständen auf den neueren virtuellen Rechnern nicht läuft. Sollten Sie Schwierigkeiten mit der VirtualBox haben, suchen Sie sich das System aus, das Ihnen gefällt und am besten auf Ihrer Hardware läuft. Grundsätzlich lassen sich alle Systeme für die Beispiele aus dem Buch verwenden. Die jeweilige Homepage der gängigen virtuellen Systeme finden Sie hier: 왘

http://www.virtualbox.org/

왘

http://www.vmware.com/de/products/

왘

http://www.qemu.com/

왘

http://www.microsoft.com/windows/virtual-pc/

왘

http://www.codeweavers.com/

왘

http://www.moka5.com/

왘

http://www.parallels.com/de/products/desktop/pd4wl/

왘

http://appdb.winehq.org/

왘

http://www.xen.org/ »Das Menschlichste am Computer ist seine Gewissenlosigkeit.« – Anonymus

471

11.1

11

Virtualisierung

11.2

Noch mehr Spaß: das JPC-Projekt

Wer nun ganz genau wissen möchte, wie derartige virtuelle Maschinen programmiert sind, kann sich das JPC-Projekt anschauen. Mitarbeiter und Studenten der Universität von Oxford haben dort die Idee realisiert, eine virtuelle Maschine in Java zu programmieren. Man kann sie direkt als Applet über einen Browser nutzen. Der Code lässt sich offiziell downloaden und nach eigenem Gutdünken erweitern und studieren, da sie der Open-Source-Lizenz unterliegt. URL

Beschreibung

http://www.physics.ox.ac.uk/jpc/index.html

JPC-Homepage

http://www.physics.ox.ac.uk/jpc/Demo2.html

Demo zur Virtualisierung mit Java

http://javapc.sourceforge.net/download_down- Quellcode des JPC-Systems load.html Tabelle 11.1

Webseiten zum JPC-Projekt

Mit einer solchen Java Virtual Machine lässt sich ein virtueller PC sogar als Applet im Browser betreiben (siehe Abbildung 11.2). So wird der virtuelle PC indirekt zu einer Art Cloud Computer mit all seinen Möglichkeiten, wenn auch nicht ganz so leistungsfähig, weil im Browser ein simulierter PC läuft, der durch die Installation mit einem Betriebssystem ausgestattet ist und am Ende Anwendungssoftware in einem Browser ausführt. Die lauffähige Software des virtuellen Rechners kann man über folgende Homepage beziehen: http://javapc.sourceforge.net/download_download.html. Es handelt sich, wie bei Java üblich, um eine Jar-Datei, die in der Konsole mit folgendem Befehl aufgerufen werden kann: Java -jar JPCApplication.jar

Die Datei liegt auch auf der Buch-DVD unter Software zum Buch\Kap11\Virtuelle Maschinen\Jpc\JPCApplication.jar. (Beachten Sie bitte die Lizenzrechte – JPC steht unter der GPL2.) Nachdem man die Datei in ein Verzeichnis auf dem Rechner kopiert hat, startet man mit »cmd« im Suchfeld des Startmenüs eine Konsole und wechselt in ihr in das Verzeichnis mit der Datei JPCApplication.jar. Wie erwähnt, lässt sie sich starten mit Java -jar JPCApplication.jar

472


Abbildung 11.2

Die JPC als Applet mit dem Spiel Doom

Allerdings muss dazu eine aktuelle Java-Version auf dem Rechner installiert sein. Ist dies nicht der Fall, erhält man eine Fehlermeldung der folgenden Art: Befehl oder Dateiname nicht gefunden: Java

Praxis Möchten Sie Java auf Ihrem virtuellen Rechner installieren, finden Sie nähere Informationen dazu auf dieser Webseite: http://java.com/de/download/. Sie werden Java ohnehin immer wieder benötigen, da es eine der meistgenutzten Programmiersprachen ist. Sinnvoll ist es daher, die Installationsdateien auf CD zu brennen, um sie bei jedem neuen virtuellen Rechner verfügbar zu haben. Nach dem Start des Programms wird ein Dialog geöffnet, der auf den ersten Blick gar nicht an einen virtuellen Rechner erinnert (siehe Abbildung 11.3).

473

11.2

11

Virtualisierung

Abbildung 11.3

Die JPC wurde gestartet.

Klicken Sie auf den folgenden Menüpunkt: File 폷 Start um die Virtualisierung zu starten. Der virtuelle Rechner wird hochgefahren und das bereits installierte FreeDOS gestartet (siehe Abbildung 11.4). Im Gegensatz zu den meisten anderen Virtualisierungen bringt JPC gleich das Betriebssystem und einige Anwendungen mit.

Abbildung 11.4

474

Der JPC wurde mit FreeDOS hochgefahren.


Neben dem bekannten FreeDOS ist auf dem virtuellen Rechner noch eine virtuelle Platte unter dem Laufwerk C verfügbar. Um auf dieses Laufwerk zu wechseln, müssen Sie den Doppelpunkt über die Combobox unter Miscellaneous Keys übernehmen, weil es dieses Zeichen auf der JPC-Tastatur nicht gibt. Das Laufwerk C trägt den Namen DOSGAMES, und das ist auch genau das, was man darauf findet. Es enthält die Spieleklassiker 왘

Invaders

왘

Keen

왘

Kong

왘

Lemmings

왘

Super-Mario

왘

Pacmania

Wenn Sie sich nun fragen, wozu man einen virtuellen PC in Java programmieren soll, so lautet die Antwort: um zu sehen, dass es möglich ist. Java hatte von jeher das Image, eine sehr langsame Sprache zu sein. Wenn man nun eines der alten DOS-Spiele ausprobiert und sich zudem noch daran erinnert, wie langsam oder wie schnell diese Spiele damals unter DOS auf dem ersten PC liefen, muss man neidlos eingestehen, dass sich der virtuelle Java-PC im Grunde nicht zu verstecken braucht (siehe Abbildung 11.5).

Abbildung 11.5

Ein schnelles DOS-Spiel auf JPC

475

11.2

11

Virtualisierung

Der Quellcode ist ebenfalls auf der DVD des Buches enthalten. Sie finden ihn unter Software zum Buch\Kap11\Virtuelle Maschinen\JPC als JPCsource.zip. Für den Java-Kenner lohnt sich in jedem Fall ein Blick in den Code. Das Projekt ist recht sauber programmiert, doch leider fehlt die zugehörige Onlinedokumentation. »Ein Programmierer ist eine Maschine, die Kaffee in Programmcode verwandelt, und ein Softwaretester jemand, der den Kaffeesatz darin heraussammeln muss.« – Anonymus

11.3

Lesen Sie weiter


Beschreibung

http://de.wikipedia.org/wiki/Virtualisierung_(Informatik)

Wikipedia-Artikel zur Virtualisierung

http://www.zdnet.de/enterprise/server/ 0,39023275,39127599,00.htm

Servervirtualisierung

http://www.zdnet.de/itmanager/toolkits/ 0,39030558,39142569,00.htm

Überblick

http://www.c0t0d0s0.org/archives/1666Loest-Virtualisierung-wirklich-irgendeinechtes-Problem.html

kritischer Artikel zur Virtualisierung

http://www.vmware.com/de/

VMware-Homepage


VirtualBox-Homepage

http://www.microsoft.com/windows/ products/winfamily/virtualpc/default.mspx

Virtual-PC-Homepage

http://www.xensource.com/Pages/ default.aspx

Xen-Homepage

http://www.physics.ox.ac.uk/jpc/ index.html

JPC-Homepage

http://www.physics.ox.ac.uk/jpc/ Demo2.html

Demo zur Virtualisierung mit Java

http://javapc.sourceforge.net/ download_download.html

Quellcode des JPC-Systems

476

»Was ist der Unterschied zwischen Jurassic Park und Microsoft? Das eine ist ein hochgezüchteter Hightech-Themenpark, basierend auf prähistorischen Informationen und in erster Linie bevölkert von Dinosauriern. Das andere ist ein Film von Steven Spielberg.« – Anonymus

12

Mein PC is’ ene Wolke

1995

1999

2006

2008

2011

Windowmaker Demo WebOS iCloud eyeOS gOS ChromiumOS

Computer sind längst selbst zu Programmen geworden. Als virtuelle Rechner haben sie in diesem Buch mehr als eine Nebenrolle gespielt. Natürlich ist das noch lange nicht das Ende der Entwicklungs-Fahnenstange. Der nächste Schritt heißt Cloud Computing. Was heißt das? Unter anderem nichts anderes, als dass ich diesen Text nicht zu Hause verfasse. Meine Textverarbeitung starte ich aus dem Internet auf einem virtuellen Cloud-PC im Browser – und das überall auf der Welt, aus einem fahrenden Zug heraus genauso wie auf einem Schiff, in Honolulu am Strand ebenso wie auf einer Forschungsstation am Nordpol.

477

12


12.1

Cloud Computing

2009 ging ein Raunen durch die Welt der Finanzen, und das nicht wegen der sogenannten Immobilienkrise, die die Welt bis an den Rand des Bankrotts geführt hat. Ganz im Gegenteil, es gab etwas, das versprach für die nächsten Jahre zu dem Wachstumsmarkt überhaupt zu werden. Wie so oft in den letzten Jahrzehnten ging es um Computer, um genauer zu sein, um Software, und um ganz genau zu sein, um die Betriebssysteme der Zukunft. Ob nun seriös oder unseriös, das mag man sehen, wie man möchte. Die Zukunft hat noch nie jemand ganz genau vorhersagen können. Schlagworte wie Cloud Computing und Sprüche wie das Ende des PCs ist gekommen, diese drei Firmen gestalten die Post-Microsoft-Ära fand man immer öfter in jedem Finanzblatt. Man wünschte Bill Gates alles Gute für die über ihn hereinbrechende Armut und Windows eine gute Nacht. Großspurig wurde versprochen, dass sich die Bedienung des Computers bald total ändern werde. Schließlich ist der Computer eine Maschine, die nach dem Einschalten minutenlang benötigt, bis wir sie verwenden können. Und dabei kann man keineswegs dort weitermachen, wo man am Tag zuvor aufgehört hatte. Nein, wir müssen uns erst alles wieder zusammensuchen, was wir während der letzten Sitzung verwendet haben. Während der Arbeit laufen wir noch immer Gefahr, durch einen Stromausfall oder einen einfachen Rechnerabsturz einen Teil oder unsere ganze Arbeit für immer zu verlieren und alles wieder neu machen zu müssen. Ganz zu schweigen von der Gefahr, der wir durch Cyberkriminelle ausgesetzt sind. Viren wollen wie ein Schwarm aufgeschreckter Heuschrecken über unseren Rechner und seine Daten herfallen, sobald wir uns mit dem Internet verbinden. Um diese Angriffe halbwegs zu überstehen, müssen wir Firewall-Programme installieren und konfigurieren, die uns behindern, wenn wir neue Software installieren oder im internen Netz irgendwelche Experimente machen wollen. Neben einer Firewall betreiben wir ununterbrochen einen Virenwächter und starten wöchentlich unseren Virenscanner, ein Programm, das täglich neue Virensignaturen übers Internet lädt, um funktionsfähig und aktuell zu bleiben. Überhaupt wollen Betriebssystem und Anwendungssoftware ständig aktualisiert und upgedatet werden oder zumindest das selbst per Internetverbindung wieder und immer wieder abwickeln. Kurzum, hätten wir vorher gewusst, was es bedeutet, einen Computer zu verwenden, hätten wir tunlichst die Finger davon gelassen. Das alles soll Cloud Computing total und nachhaltig ändern.

478

Cloud Computing

Andererseits, es mag ja sein, dass seit Konrad Zuse nicht jeder Nutzer immer mit seiner Superrechenmaschine zufrieden war. Das ändert jedoch nichts an der Tatsache, dass der Computer die größte technische Entwicklung nach der Dampfmaschine und dem E-Motor ist. Wenn es vielleicht auch den Anschein einer großen Wende hat, darf man dabei nicht vergessen, dass dies die Vernichtung von Millionen von Arbeitsplätzen bedeuten würde. Alte Strukturen würden unweigerlich untergehen, und es würde Jahrzehnte dauern, bis die neuen Arbeitsplätze wieder so vielen Menschen Brot geben, wie es die alten heute noch tun. Trotzdem wird niemand die Entwicklung aufhalten können. Wenn ein neues Kapitel in der Geschichte der Computer aufgeschlagen werden kann, wird dies auch getan.

12.1.1

Was ist Cloud Computing?

Mit Virtualisierung haben wir uns bereits auseinandergesetzt. Ein virtueller Computer ist ein in Software realisierter Standardrechner. So ein Gerät aus Bits und Bytes ist keineswegs an die heimische Hardware gebunden. Theoretisch könnte ein virtueller PC überall und nirgends sein, also auch einfach auf einer Internetadresse im Netz. Genau dieser Schritt ist der Schritt vom virtuellen Rechner zum Cloud-Rechner. Am 8. Juli 2009 hat Google bekanntgegeben, dass man ein neues Betriebssystem entwickeln werde, das eine direkte Konkurrenz zu den Windows-Systemen von Microsoft darstellt. Das neue Betriebssystem erhielt den vielsagenden Namen Chrome OS. Das Ganze ist schon aufregend genug, wer traut sich schon zu, es mit dem Softwaregiganten Microsoft aufzunehmen? Doch um die Sensation perfekt zu machen, ließ Google verlauten, dass dieses Betriebssystem ein Mitglied der nächsten Betriebssysteme-Generation sein wird, ein Cloud-Betriebssystem. Die Begriffe Cloud Computing und Cloud-Betriebssystem hat nicht Google erfunden. Sie stammen aus den letzten Jahren des 20. Jahrhunderts von Prof. Ramnath K. Chellappa und beziehen sich auf das Wolkensymbol, das man in Diagrammen schon lange benutzte, um das Internet anzudeuten. Es steht für beliebig große Ressourcen an Rechenleistung und Speicherplatz, die zwar konkret nicht zu lokalisieren, aber überall verfügbar sind. Cloud Computing stellt dabei nicht unbedingt so etwas wie ein Betriebssystem dar, mit Desktop-Oberfläche, Dialogfenstern, Menüs und Icons. Es handelt sich vielmehr um eine Plattform, auf der man eigene und fremde Software in beliebigem Umfang und mit beliebiger Leistung betreiben und übers Internet nutzen kann. Teil einer solchen Software-Umgebung kann natürlich auch eine Art virtuelles Betriebssystem sein. Mit dieser Form werden wir uns in diesem Kapitel vor-

479

12.1

12


rangig auseinandersetzen, ohne die weiteren Möglichkeiten des Cloud Computings ganz außer Acht zu lassen. Natürlich ist es lediglich ein böses Gerücht, dass Windows 7 nur deshalb besser als Windows Vista geworden sei, weil Google sein Cloud-Betriebssystem, ChromeOS, angekündigt hat. Das Schreiben von Büchern kann langwierig sein, so ist es wahrscheinlich, dass der Leser dieser Zeilen Chrome OS bereits verwenden kann. Betaversionen sind jetzt schon im Internet zu finden. Wieso Chrome OS? Heißt das nicht gOS, werden Sie sich vielleicht fragen. Richtig, aktuell gibt es ein System namens »gOS Gadgets«, was »good OS«, also »gutes Betriebssystem«, bedeutet. Der Zusatz »Gadgets« steht für die Online-Programme von Google. gOS selbst stammt allerdings nicht von Google. Von Google angekündigt wurde ein Cloud-OS mit dem Namen Chromium OS, weil es auf dem Browser von Google, dem Chrome, beruhen soll. Danach gab es die verschiedensten Gerüchte, Betas, Quellcode-Freigaben und Ähnliches mehr. Eine lauffähige Binärversion gibt es allerdings noch nicht. Wenn man es versuchen möchte, muss man den Quellcode entweder selbst auf einem 64-Bit-Linux kompilieren oder ein VMware Image nutzen, das als einzige lauffertige Version bis heute verfügbar ist. Praxis: gOS gOS, so wie es aktuell vorliegt, ist kein Cloud-System, sondern eine Chimäre, die auf einem vollwertigen Ubuntu-System beruht, auf dem Anwendungen laufen, die sich der Rechner von Google aus dem Internet holt. Mit einem echten CloudSystem hat das reichlich wenig zu tun. Als solches ist es auch nicht gedacht, denn dieses System heißt nach wie vor Chrome OS und ist noch in der Entwicklung. Alles zu Chrome OS finden Sie unter http://www.chromium.org/chromium-os. Die Betaversion von gOS findet man zurzeit im Internet unter der URL http:// www.thinkgos.com/gos/download.html. Die aktuelle Version gibt es auch auf der Buch-DVD: Software zum Buch\Kap08\goodOS\gos-3.1-gadgets-20081205.iso. Es handelt sich um eine ISO-Datei, die man am besten auf eine CD brennt, bevor man sie zur Installation auf einer virtuellen Maschine nutzt. Wie das bei Betaversionen öfter der Fall ist, gelingt das nicht ohne Weiteres. Bei mir ging es ganz gut mit den Einstellungen für ein Ubuntu-System auf VMware (wen wundert's – ist ja nur ein Ubuntu mit aufgepeppter Oberfläche). Nach der Installation wird beim Start des Rechners der Logon-Bildschirm angezeigt.

480

Cloud Computing

Abbildung 12.1

Einloggen in ein »gutes« Betriebssystem

Wer die Gagets von Google wenig einsetzt oder gar davor zurückschreckt, kann sie mit dem gOS im virtuellen Rechner ausgiebig kennenlernen. Um Chromium OS selbst einmal auszuprobieren, benötigt man zunächst einen sogenannten gmail-Acount. Den erhält man am einfachsten, wenn man sich bei Google Mail anmeldet (http://www.gmail.com). Nachdem Sie die Schaltfläche Konto erstellen >> angeklickt haben, gelangen Sie auf die Anmeldeseite, auf der Sie Ihren Zugangsnamen und das Passwort festlegen können. Wie bei modernen E-Mail-Accounts üblich, geht der Vorgang sehr rasch, und Google bietet eine ganze Reihe von Diensten, bei denen man sich mit diesem Zugang anmelden kann. Nun können Sie sich das VMware Image von Chrome OS besorgen. Sie finden es an verschiedenen Stellen im Internet, einen offiziellen Anbieter scheint es nicht zu geben. Die Chromium-Seite bietet lediglich den Quellcode, mit dem man das Image selbst kompilieren kann. Deshalb befindet sich das Image auch auf der Buch-DVD unter Software zum Buch\Kap12\ChromeOS\chromeos-image-999. 999.32309.211410-a1.vmdk.

481

12.1

12


Abbildung 12.2

E-Mail-Konto bei Google anlegen

Nachdem Sie die Datei irgendwo auf Ihrer Festplatte abgelegt haben, können Sie eine virtuelle Maschine starten, um sich Chrome OS anzusehen. Nach dem Start von VirtualBox legen Sie mit Neu eine neue virtuelle Maschine an. Wählen Sie Linux 폷 Ubuntu als Betriebssystem. Lassen Sie bei der Boot-Festplatte keine Festplatte erzeugen, sondern wählen Sie die auf die Festplatte kopierte vmdk-Datei aus (siehe Abbildung 12.3).

Abbildung 12.3

482

Als Festplatte das Chrome Image angeben

Cloud Computing

Das ist eigentlich alles. Wenn Sie den virtuellen Rechner nun starten, sollten Sie ziemlich rasch (ca. drei Sekunden) den Anmeldebildschirm des Chrome OS zu sehen bekommen (siehe Abbildung 12.4). Dort melden Sie sich nun mit dem reservierten Namen und Passwort an. Das Programm ergänzt selbsttätig das @gmail.com, weshalb Sie nur den Anmeldenamen einzutippen brauchen.

Abbildung 12.4

Chroms spartanisches Tor

Was man jetzt zu sehen bekommt, ist lediglich die Oberfläche eines Browsers, eben des Chrome-Browsers von Google. Nun hat man natürlich auch die Möglichkeit, von diesem Browser aus die Google-Gagets zu verwenden (siehe Abbildung 12.5). Das kann natürlich nicht der Weisheit letzter Schluss sein. Zumindest kann man damit kein Microsoft-Unternehmen vom Thron stoßen. In der Tat ist ein Browser, der sich wie ein Betriebssystem starten lässt, auch nicht alles. Was fehlt, ist das Eigentliche, die Arbeitsfläche, der Desktop für das Cloud-Betriebssystem. Theoretisch könnte man diesen vom Client erzeugen lassen und nur den Hintergrund als Webbrowser laufen lassen, wie gOS bereits andeutet. Zurzeit gibt es von Chrome OS noch nicht mehr zu sehen. Es bleibt also nichts anderes, als abzuwarten. Was es allerdings bereits eine ganze Weile gibt: funktionierende Cloud-OS-Seiten von anderen Anbietern. Genau diese wollen wir uns auch ansehen, nachdem wir uns kurz darüber informieren, wie die Idee vom Computer aus dem Internet eigentlich entstanden ist. 483

12.1

12


Abbildung 12.5

12.1.2

Google-Programme mit Google Chrome OS

Die Anfänge des Cloud Computing

Im Nachhinein ist es immer schwer, die Anfänge zu finden, wenn sie seinerzeit nicht groß beachtet worden sind. Genauso ist es beim Cloud Computing. Irgendwann kam jemand auf die Idee, statt einer Webseite den Desktop eines PCs im Browser darzustellen, und schon war die Idee des Computers aus dem Internet geboren. Für Linux gibt es verschiedenste sogenannte Desktop-Umgebungen und Windowmanager. Eine davon nennt sich Window Maker. Sie orientiert sich direkt am Betriebssystem NextStep, das Steve Jobs damals für den Next entwickeln ließ. Um den interessierten Nutzern diese neue Oberfläche in Aktion zu zeigen, programmierte vor 1996 einer der freien Mitarbeiter im Window-Maker-Projekt eine Webseite, die diese Oberfläche in Aktion zeigte. Man konnte Fenster öffnen, verschieben, einen Editor nutzen und Icons positionieren. Leider ist die Seite heute im Internet nicht mehr verfügbar. Nur im Webarchiv existiert noch ein toter Link darauf von 1998: http://web.archive.org/web/ 19991008125221/rive.boxybutgood.com/WindowMaker/.

484

Cloud Computing

Das Webarchiv Internetseiten sind hin und wieder kurzlebig wie Eintagsfliegen. Aber auch bekannte Seiten, die viele Jahre im Netz stehen, ändern hin und wieder ihr Gesicht und verschwinden am Ende ganz. Um diese Kunstwerke des WWW zu konservieren, wurde in San Francisco in Amerika das Webarchiv gegründet. Es fungiert als gemeinnütziges Projekt seit 1996 und wurde von Brewster Kahle ins Leben gerufen. Ähnlich wie bei den Suchmaschinen durchforsten Webagenten das Internet und finden neue eingestellte Seiten, die zunächst einmal zwischengespeichert werden. Erst nach sechs Monaten kommen sie in den allgemein zugänglichen Index und können von jedermann über die Webseite aufgerufen werden. Die Webseiten werden natürlich nicht eins zu eins kopiert auf den Servern des Archivs abgelegt, sondern gepackt. Die Darstellung der archivierten Seiten wird mit der sogenannten Wayback Machine (»Take Me Back«) aufgerufen. Dabei erscheint zuerst ein Jahreskalender über die Jahre, in denen die fragliche Webseite im Internet angetroffen wurde. Unter jedem Jahr gibt es für den direkten Aufruf der Seiten Linklisten, in denen jeder Eintrag für eine Version der Webseite steht. Bisher enthält das Archiv über 150 Milliarden Webseiten, ohne allerdings vollständig zu sein. Am häufigsten fehlen größere Abbildungen, die offenbar als Platzgründen weggelassen wurden. Außerdem gibt es natürlich keine Einträge von vor 1996, die erste Webseite der Welt von 1990 wird man also vergebens suchen. Aber eine Seite der Firma Next von 1997 ist beispielsweise abrufbar: http://web. archive.org/web/19970418053013/www.next.com/AboutNeXT/. Neben den Webseiten möchte das Archiv weitere Internetsourcen wie Computersoftware und Computerspiele archivieren.

Nach der Idee für Window Maker kam das erste richtige Cloud-Betriebssystem mit dem Namen WebOS (nicht zu verwechseln mit dem neuen Palm-Betriebssystem, das nun samt Unternehmen von HP übernommen wurde). Es war in einigen Linux-Distributionen enthalten, aber außerhalb der Communitys kaum bekannt: Ende des letzten Jahrhunderts begann die Idee eines Web-Betriebssystems mehr und mehr Gestalt anzunehmen. Pishevar K. Shervin und Drew E. Morris gingen daran, Lizenzen auf die bereits bestehenden Internet-OS-Patente der Duke University und der University of Texas zu erwerben. Außerdem gelang es ihnen, weitere Fachleute auf dem Gebiet der Webprogrammierung, wie z. B. JavaScript, zu rekrutieren. Auf dieser Basis wurde im Februar 1998 die Firma WebOS Inc gegründet. Eine der ersten Webseiten der WebOS Inc kann man im Internetarchiv anschauen: http://web.archive.org/web/20010208190539/www.webos.com/webos/ index.cfm.

485

12.1

12


Abbildung 12.6

Webseite der Firma WebOS

Bereits 1999 konnte man als Applikation für WebOS ein vollständiges OfficePaket anbieten: HyperOFFICE. WebOS war jedoch auf dem amerikanischen Markt nicht allein, es gab weitere Startups wie Desktop.com: http://web. archive.org/web/20000229112109/desktop.com/site/platform.html. WebOS erregte mit seinem Vorhaben, eine neue Art Betriebssystem zu etablieren, in Amerika großes Aufsehen. Alle bekannten Medien – vom Wall Street Journal bis zum CNN – berichteten ausführlich darüber. Dadurch wurde die Idee eines Betriebssystems im Web allgemein bekannt. Trotz dieser Publizität gelang es nicht, den Nutzer davon zu überzeugen, das System zu akzeptieren und in diese neue Technik einzusteigen. WebOS bot das Office-System HyperOFFICE noch eine ganze Zeit an. Letztendlich scheiterte es jedoch genauso wie Desktop.com. Doch die Idee war geboren, und überall in der Welt arbeitete man hinter verschlossenen Türen an Cloud-Lösungen. Man schwieg, bis Google in einen Zwist

486

Cloud Computing

mit Microsoft geriet, weil Microsoft-Chef Ballmer angekündigt hatte, mit einer neuen Suchmaschine Google Konkurrenz machen zu wollen. Im Gegenzug kündigte Google an, nun ein Betriebssystem zu entwickeln, um Microsoft das Fürchten zu lehren. Die eigentliche Sensation dabei wurde die Aussage von Google, dass es kein herkömmliches System sein würde, sondern ein System, das aus dem Internet kommend innerhalb eines Browsers laufen würde.

12.1.3

Ein mehrdeutiger Begriff

Es gilt zu bedenken, dass der Begriff Cloud Computing zwiegespalten ist. Einmal umfassen sie Systeme, die Software für Kunden als Remote-Applikation zur Verfügung stellen. Das kann so aussehen, dass man gar keine bestimmte Betriebssystemoberfläche auf dem Monitor des NC (Netcomputers) zu sehen bekommt, sondern nur die speziellen Anwendungen, die man nutzen möchte. Die zweite Bedeutung kommt dem ein gutes Stück näher, was man gemeinhin als Betriebssystem ansieht. Ähnlich wie bei einem Internet-E-Mail-Client logt man sich über ein Webportal in eine Anwendung ein, bekommt jedoch statt der Tabelle mit eingegangenen E-Mails eine grafische Oberfläche zu sehen, die doch auffallend an den Windows-Desktop erinnert (siehe Abbildung 12.7).

Abbildung 12.7

Desktop von icloud im Firefox-Browser

487

12.1

12


Die Illusion ist fast zu perfekt, jeder Windows-Nutzer fühlt sich in einem solchen System sofort zu Hause. Trotzdem ist es etwas ganz anderes als ein virtueller Rechner oder gar die reale Hardware zu Hause unterm Schreibtisch. Das Erste, was sich wahrscheinlich bemerkbar macht, ist die Übertragungsgeschwindigkeit des Internetanbieters. Bei einem schnellen Netzanschluss wird man kaum einen Unterschied zum lokalen Betriebssystem bemerken. Bei einem langsamen Netz wird man dagegen kaum mit dem Cloud-Desktop arbeiten können.

12.1.4

iCloud

Nachdem WebOS gescheitert war, zählte icloud zu den ersten Adressen der Cloud-OS-Anbieter, auch wenn die Behauptung, »der erste Online-Computer zu sein«, nicht ganz überzeugt. icloud versteht sich in erster Linie als Anbieter einer individuellen Desktop-Oberfläche über das Internet, so dass jeder Nutzer von jedem Ort und Rechner der Welt in einer ihm gehörenden Arbeitsumgebung am Rechner werkeln kann. Unter dem iExplorer benötigt iCloud Java, im Netscape wird JavaScript ausgiebig genutzt, aktuell allerdings noch mit Fehlfunktionen. Die Bedienung erinnert sehr an Windows. Links unten gibt es eine große Schaltfläche, mit der das Hauptmenü ausgeklappt wird. Das ist offensichtlich eine Kopie des Windows-Menüs, in dem links die Favoriten angezeigt werden und man rechts einen Überblick über alle verfügbaren Programmgruppen sieht. Für die Entwickler des icloud-Systems war dies jedoch ein wichtiger Punkt. Die Nutzer sollten das Gefühl haben, in einer gewohnten Umgebung zu sein, um keine Einarbeitungsphasen zu benötigen. Es gibt eine ganze Reihe kleiner Applikationen wie eine Uhr, einen Kalender für Termine, einen Aufgabenplaner und Ähnliches mehr. icloud ist ein Produkt der schwedischen Firma Xcerion. Sie hat ihren Stammsitz in Linköping und wurde im Jahr 2001 von Daniel Arthursson gegründet. Er ist heute der Präsident des Unternehmens, Jonas Thornholm ist Vizepräsident, Finanzchef und Leiter der amerikanischen Aktivitäten. Stolz ist man vor allen Dingen auf die Entwicklungsumgebung des Systems. Software für das System kann in HTML, JavaScript und Java entwickelt werden. Aber es gibt auch ein ganz neues Konzept, das sich Xidezone nennt und ausschließlich mit XML auskommt. Laut Xcerion ist damit die Programmierung ohne tiefere Programmierkenntnisse möglich. Ein Grund, sich das Ganze einmal genauer anzusehen.

488

Cloud Computing

Praxis Was man zunächst braucht, ist ein Zugang zu icloud, damit man überhaupt etwas für dieses System entwickeln kann. Starten wir die Seite, indem wir sie aufrufen: http://icloud.com/de oder http://os.icloud.com.

Abbildung 12.8

Zugang zum Online-Computer

Hat man noch keinen Zugang, klickt man auf den Link Mitglied werden unterhalb der Zugangsfelder rechts. Ein Dialog zum Erstellen des Accounts öffnet sich und man trägt einen Benutzernamen, seinen Namen, die E-Mail-Adresse und das gewünschte Passwort ein. Nun kann man icloud mit den erstellten Zugangsdaten starten. Nach dem Startvorgang zeigt sich der Desktop, der sehr an Windows erinnert. Uns interessiert nur ein einziger Menüpunkt aus dem Startmenü hinter der Wolke: Start 폷 Entwicklung 폷 Entwicklungsumgebung (Alpha). Das Alpha hinter der Entwicklungsumgebung sagt uns nur, dass wir uns eventuell auf einige unschöne Effekte freuen können. Im Internet Explorer läuft die Software jedoch recht stabil, mit anderen Browsern ist in der aktuellen icloudVersion keine Softwareentwicklung möglich. Der erste Dialog, der geöffnet wird, nennt sich Manage Application Project und dient dazu, die Projekte zu verwalten (siehe Abbildung 12.9). Wählen Sie den Eintrag FirstApp, und klicken Sie anschließend auf Open. Eine IDE öffnet sich, die einen GUI-Editor und einen XML-Editor zur Programmierung bietet.

489

12.1

12


Abbildung 12.9

icloud-Projektverwaltung

Zwei Reiter mit der Aufschrift FirstApp erlauben das Hin- und Herschalten zwischen der GUI und der Code-Entwicklung.

Abbildung 12.10

Entwicklungsumgebung mit Demoprojekt

Der GUI-Editor ist in seiner Art dem .NET-BASIC oder dem Visual Basic nachempfunden. Es gibt links die Tool Bar bzw. Components Bar, in der Mitte das Editor-Fenster mit der GUI-Zeichenfläche und dem Code-Editor. Rechts stellt

490

Cloud Computing

man die Properties ein. Außerdem gibt es eine Strukturübersicht und die Liste der Events. Für die Entwicklung der eigenen Applikation lässt sich die Demo-FristApp auf recht einfache Weise umbauen. Als Erstes werden die Namen über die Strukturtabelle am rechten Rand geändert. Als Nächstes baut man die Menüs ebenfalls mit Hilfe der Strukturtabelle neu auf. Beispielhaft wird die Oberfläche des Java-Gänseblümchen-Projekts mit icloud nachempfunden. Das Java-Projekt liegt auf der DVD unter Software zum Buch\ Kap12\Gänseblümchen. Das Layout lässt sich mit Hilfe der Insert Layout Actions oben links relativ einfach aufbauen. Man wählt in der Struktur das root-Panel aus und wählt Insert Layout und darin 3-Column. Dadurch werden drei Panel in das root-Panel gelegt. Die Panel lassen sich mit Hilfe der Parameter mode und look gestalten, so dass man genau sieht, wo sie liegen. Ihre Größe lässt sich prozentual festlegen, aber auch in Pixelbreite. Wenn man drei Panels in Spalten angeordnet hat, kann man die fünf Radiobuttons einfügen, die der Dialog benötigt.

Abbildung 12.11

Gänseblümchen-Dialog in icloud

491

12.1

12


Die Einstellungen der Root-Komponente sind interessant in Bezug auf das Gesamtverhalten. Hier kann man den Dialog modal1 setzen und einen SplashScreen2 aktivieren. Die Entwicklungsumgebung befindet sich jedoch noch im Alphastadium und läuft daher nicht sonderlich stabil. Deshalb soll es genügen, wenn wir die Oberfläche so gut wie möglich nachgebildet bekommen. »Der Programmierer ist der Vormund des Anwenders.« – Pirmin Krüsi

12.1.5

eyeOS

eyeOS, ein weiterer Cloud-PC, ist einfacher aufgebaut als icloud, deshalb aber auch schneller und einfacher zu bedienen. Er basiert rein auf HTML und benötigt kein JavaScript oder spezielle Plugins für die Browser. Die Homepage des Anbieters (siehe Abbildung 12.12) ist http://www.eyeos.com/. Auch bei eyeOS benötigt man zunächst einmal einen Account, wenn man sich das System im Internet ansehen möchte. Das ist jedoch bei diesem System ganz einfach. Sobald man sich auf der Seite befindet (http://classic.my.eyeos.org/), kann man sich über die Schaltfläche Neu unter einem beliebigen Namen und Passwort registrieren lassen. Für die Entwicklung von Software für eyeOS ist es jedoch wichtig, ein eigenes eyeOS-System auf dem heimischen Rechner aufzusetzen. Die Softwareentwicklung findet nicht im System selbst statt, deshalb muss man die Programme zum Testen der Software immer erst auf den Server bringen. Würde man dies jedes Mal übers Internet tun, dauerte die Entwicklung der Software ewig. So kann man die Daten direkt im entsprechenden Verzeichnis erstellen und unmittelbar testen. Dabei ist es natürlich interessanter, wenn man ein Netzwerk zur Verfügung hat und die Tests von einem anderen Client aus durchführen kann. Die Installation von eyeOS Um eyeOS betreiben zu können, benötigt man den Apache-Webserver und die Sprache PHP in der Sprachversion PHP5. Weil Apache aus der Linux-Ecke kommt, ist es sinnvoller, ihn auch unter Linux einzusetzen.

1 Modal = besitzt den Fokus (Mauszeiger) bis zum Schließen. 2 Eine Begrüßungsgrafik

492

Cloud Computing

Abbildung 12.12

eyeOS-Homepage

Nachdem wir Ubuntu-Linux in einem virtuellen Rechner eingerichtet haben, installieren wir den Apache und danach PHP5 per Synaptic-Paketverwaltung. Um E-Mails auch mit eyeOS nutzen zu können, müssten noch die Pakete PHP5SQLite und PHP5-IMAP installiert werden (siehe Abbildung 12.13). Apache richtet das Verzeichnis /var/www ein. In diesem Verzeichnis liegt zunächst nur eine Demoseite, die sich meldet, wenn wir im Browser zur Localhost-URL wechseln. Diese Seite ersetzen wir durch den gesamten Inhalt der folgenden Datei: Software zum Buch\Kap12\eyeOS\eyeOS_1.8.7,1.zip. Natürlich können wir die Datei alternativ auch von der eyeOS-Homepage beziehen. Die in der Datei enthaltenen Dateien und Verzeichnisse müssen wir komplett freigeben, also mit sudo chmod 777 * -R

493

12.1

12


Abbildung 12.13

Zur Installation bereit

Auch das Verzeichnis www muss freigegeben sein: sudo chmod 777 www -R

im /var-Verzeichnis ausführen. Vergessen Sie nicht, nach der PHP-Installation den Apache neu zu starten: sudo /etc/init.d/apache2 restart

Wenn Sie nun http://localhost im Browser aufrufen, könnte die eyeOS-Seite bereits erscheinen (siehe Abbildung 12.14). Es kann aber auch sein, dass der Browser eine PHTML-Datei speichern will. In diesem Fall läuft PHP noch nicht richtig im Server (siehe Abbildung 12.15). Hier hilft eventuell folgende Zeile weiter: sudo a2enmod php5

Ansonsten hilft nur eine Neuinstallation der Komponenten weiter oder die Installation eines Pakets, in dem beispielsweise der Apache, PHP und MySQL enthalten sind, wie man es im Netz vielfach findet. So beispielsweise XAMPP unter http://www.apachefriends.org/de/xampp.html. Auch die Ubuntu-Hilfeseiten sollte man bemühen, falls es ernsthafte Probleme mit der Installation gibt. 494

Cloud Computing

Abbildung 12.14

eyeOS-Zugangsdialog

Abbildung 12.15

PHP5 läuft noch nicht in Apache.

495

12.1

12


Meldet sich die eyeOS-Installationsseite richtig, geben Sie das Passwort zweimal ein, vergessen bitte nicht, Besucher dürfen sich registrieren zu aktivieren, und starten die Installation (siehe Abbildung 12.16). Das Passwort ist das Root-Passwort, das anzugeben ist, wenn man sich mit dem Namen »Root« in den Cloud-Rechner einloggt.

Abbildung 12.16

Passwort festlegen und Installation starten

Nach dem Anklicken der Schaltfläche eyeOS installieren! geht es zügig weiter zum Authentifizierungsdialog (siehe Abbildung 12.14). Nun kann man sich entweder als Root mit dem reservierten Passwort einloggen oder auf die Schaltfläche New User klicken und sich als neuer Nutzer anmelden, beispielsweise so: 왘

Username: Testnutzer

왘

Password: testen

Wir sehen nun einen Desktop mit lichtblauem Hintergrund. Das Menü ist wie bei einer Windows-Anwendung als Menüleiste in der Kopfzeile untergebracht.

496

Cloud Computing

Abbildung 12.17

Es kann losgehen!

Die ersten vier Punkte sind Menüspalten, die restlichen Icons dienen dazu, bestimmte Anwendungen direkt aufzurufen. Natürlich lässt sich die Menüzeile auch editieren. Dazu klicken Sie sie mit der rechten Maustaste an. Am linken Rand finden Sie in Form von größeren Icons die wichtigsten Anwendungen. Darunter auch Applications (Programme), über das sich ein Dialog öffnet, mit dem die verfügbaren Anwendungen ausgewählt und gestartet werden können. Wir wollen uns jetzt einmal anschauen, wie man eine solche Anwendung erstellt. »Die Computerrevolution ist vorbei – die grauen Kästen haben gewonnen.« – Graffito Praxis Softwareentwicklung für eyeOS ist multilinguale Entwicklung. Das bedeutet, man sollte mit JavaScript, XML und PHP umgehen können, um Anwendungen für dieses Cloud-System zu erstellen. Die wichtigste Sprache ist jedoch PHP. Für jede Anwendung gibt es ein eigenes Verzeichnis, das den Namen der Anwendung trägt. Der Pfad zum eyeOS-Verzeichnis ist in jedem Fall /var/www und nicht wie bei Linux üblich das Verzeichnis des aktuellen Users. In diesem Unter497

12.1

12


verzeichnis gibt es ein eyeOS-Verzeichnis, das mit eyeOS beginnt und mit einer Nummer endet, z. B. eyeOS133dc9d447. In der folgenden Tabelle wird dieser Name einfach mit eyeos abgekürzt. Die Anwendungsnamen der zu eyeOS gehörenden Anwendungen beginnen jeweils mit eye. Die Verzeichnisstruktur hat folgenden Aufbau: Verzeichnis

Bedeutung

eyeos/apps/

Verzeichnis für den Code der Anwendungen

eyeos/apps/anwendungsname/

Root-Verzeichnis der jeweiligen Anwendung

eyeos/apps/anwendungsname/app.eyecode

PHP-Code für die Oberfläche der Anwendung, sozusagen der clientseitige Code

eyeos/apps/anwendungsname/event.eyecodes

Ereignissteuerung der Anwendung

eyeos/apps/anwendungsname/info.xml

XML-Beschreibung der Anwendung; nicht zwingend erforderlich, aber sinnvoll

eyeos/apps/anwendungsname/extern/

Verzeichnis für die Metadateien der Anwendung, z. B. Abbildungen, Properties usw.; Browserzugriff muss möglich sein

Tabelle 12.1

Pfade der eyeos-Verzeichnisse

Die app.eyecode-Datei steuert das Aussehen der Oberfläche, sorgt also im Browser für den Aufbau und die Kommunikation mit dem Anwender, die events.eyecode-Datei behandelt die internen Ereignisse. Die Zugehörigkeit der Elemente und der Eventfunktionen steuert man über deren Namen. Zu einem MoreFun-Button gehört eine on_MoreFun_Button-Funktion. Außerdem gehört der Name der Applikation noch vor den Funktionsnamen, also MoreFun_on_MoreFun_Button. Beispiel: Wir legen im Verzeichnis /var/www/eyeOSxxxxx/apps das Verzeichnis MoreFun an. In diesem Verzeichnis erstellen wir nun drei Dateien und zuerst die Datei app.eyecode.

Der Applikationsname und run stellt die Funktion dar, die aufgerufen wird, sozusagen den Konstruktor. Der Destruktor darf natürlich nicht fehlen. Dieser heißt demnach Applikationsname_end.

498

Cloud Computing

Hier nun die Funktionen von events.eyecode:

Was nun noch fehlt, ist die XML-Datei mit der Definition der Anwendung: <package> MoreFun Utilities 0.1 <description>Test mit Textanzeige mySelf AGPL Utility index.php?theme=1&extern=icons/48x48/rename.png

Damit ist die Anwendung erstellt. Es ist auch gar kein Übersetzungslauf oder Neustart des Servers nötig. Man muss nur noch die Anwendung von eyeOS aus aufrufen. Dazu klicken Sie die Applications an und in diesem Dialog die LaunchApp. Es öffnet sich ein einfacher Dialog Run..., in dessen Textfeld wir den Namen unserer Anwendung eintragen: MoreFun. Die Schaltfläche Run sollte den Dialog unserer neuen Anwendung öffnen. Den Text, den wir ins Textfeld schreiben, stellt das Programm nach Anklicken der Schaltfläche hinter die Frage. Wer das Beispiel nicht abtippen möchte, findet es auf der DVD: Software zum Buch\Kap12\eyeOS\Projekte\MoreFun.

501

12.1

12


Dateien auf den Cloud zu übertragen ist ganz einfach. Man klickt mit der rechten Maustaste in den Dateimanager. Das geöffnete Kontextmenü enthält die Option Hochladen. Klickt man auf eine Datei im Dateimanager, erscheint im Kontextmenü stattdessen der Punkt Herunterladen.

12.1.6

Sag mir, wo die Daten sind

Das englische Wort »Cloud« heißt auf Deutsch »Wolke« und steht symbolisch für das Internet, also für etwas »Nebulöses«, etwas, was man nicht greifen kann. Beim Cloud Computing stellt diese Wolke dem Nutzer vor allem Rechenleistung zur Verfügung. Die größte Problematik dabei ist die Anonymität der Rechenleistung. Man weiß im Grunde nicht, wo die Daten verarbeitet werden, die man dem Cloud-System zur Bearbeitung überlässt. Man kann zwar die Dienste eines großen Anbieters wie Google, Amazon oder Microsoft in Anspruch nehmen und darauf vertrauen, dass die sensiblen Daten irgendwo hinter dicken Mauern in den Servern eines Firewall-geschützten Racks verarbeitet werden, doch wer will das schon garantieren? Was, wenn der Anwender aus Kostengründen ein Grid benutzt und die Daten auf die Rechner freiwilliger Helfer lädt? Es muss ja keine böse Absicht dahinterstehen, wer will einem Anbieter übel nehmen, wenn er aus Auslastungsgründen für Spitzenzeiten auf ein Grid ausweicht? Im Grunde kann man sich als Nutzer nicht sicher sein, wem man seine Daten zur Verarbeitung anvertraut. An der Lösung dieses Problems wird seit dem Aufkommen der Idee des Cloud Computings gearbeitet. Microsoft hat mit anderen Firmen zusammen den sogenannten Internet-Service-Bus (ISB) entwickelt. Er dient dazu, Cloud-Anwendungen in einem sicheren Umfeld und Single Sign-on einem potentiellen Anwender zur Verfügung zu stellen.

12.1.7

Cloud-Dienste

Vorgesehen ist der November 2011. Dann wird auf dem Europäischen Raumfahrtbahnhof Kourou in Französisch-Guayana eine russische Sojus-Fregat-Rakete abheben und sich auf den Weg ins Weltall machen. An Bord eines der schärfsten künstlichen Augen, die der Mensch bis jetzt geschaffen hat: der Gaia-Satellit. Sein Name leitet sich von »Globales, Astrometrisches Interferometer für die Astrophysik« ab, hat aber auch noch die alte Bedeutung »Erde«.

502

Cloud Computing

Mit diesem Satelliten will die ESA über eine Milliarde Sonnen unserer Milchstraße, also unserer Heimatgalaxie, untersuchen. Dabei sollen ihre Positionen ganz exakt bestimmt und so viele Daten wie möglich erfasst werden. Logischerweise fallen bei diesem Projekt gewaltige Datenmengen an. Deshalb hat sich die ESA bereits im Vorfeld nach einer Möglichkeit umgesehen, so große Datenmengen kostengünstig zu verarbeiten. Anstatt auf die Idee zu verfallen, ein Gaia@home ins Leben zu rufen, also Grid-Computing oder Computercluster einzusetzen, möchte man es mit der neuen Technik des Cloud Computings versuchen. Und das insbesondere deshalb, weil die Daten stoßweise anfallen werden. »Alle sechs Monate müssen wir alle Beobachtungen schnellstmöglich verarbeiten (in der Regel in zwei Wochen), und AWS konnte uns dabei helfen. Nach sorgfältiger Prüfung haben wir festgestellt, dass Amazon Web Services von allen öffentlichen Clouds die meisten Funktionen zu bieten hatte.« – Paul Parsons, Chef der Firma The Server Labs Seit einiger Zeit bieten große Rechenzentren, die Unternehmen wie Amazon oder Google gehören, nämlich nicht nur ihre üblichen Dienste an, sondern erlauben Kunden auch, ihre Rechner zu nutzen. Natürlich ist dies nur auf Basis eines virtuellen Zugriffs und nicht im direkten Sinne möglich. Das Ganze nennt sich SaaS. SaaS steht für »Software as a Service« und ist Teil der vielgliedrigen Cloud-Technologie: Bei Single-Sign-on-Authentifizierung ermöglicht man dem Anwender, nach einer einzigen Anmeldung mehrere Dienste sicher nutzen zu können. Auf dem heimischen Rechner ist Single Sign-on im Grunde Alltag: Ist man im Betriebssystem, kann man alle installierten Programme starten, ohne sich noch einmal identifizieren zu müssen. Im Internet und damit im Cloud Computing ist das nicht so einfach. Unter einer Oberfläche kann man verschiedene Programme starten, die keineswegs auf einem Rechner laufen müssen. Man nutzt eine Textverarbeitung aus Kalifornien und ein Grafikprogramm aus Griechenland. Also muss man sich ständig neu als berechtigter Nutzer zu erkennen geben. Genau dieses Problem löst man mit Single Sign-on, an dessen Verwaltung man sich einmal anmeldet und dann die Berechtigung bei allen zu startenden Programmen geltend macht. Bei ISB heißt diese Verwaltung Identity Network Service (INS). Ein Anwendungsbeispiel für Cloud Computing und den ISB ist das sogenannte CRM (Customer Relationship Management). Hier geht es darum, im Bereich Handel die Kundenbeziehungen jederzeit verfügbar zu haben, aber umfassend mit einer entsprechenden Software zu pflegen. Wie leicht zu erkennen ist, benö-

503

12.1

12


tigt man dazu verschiedene Datenbanken und Anwendungen. Interne Angestellte müssen genauso Zugriff haben wie Heim- oder Außendienstmitarbeiter. Dafür sind ISB und Cloud die beste Basis. CRM selbst sollte dies alles unter einer Oberfläche und systemübergreifend bieten, zusätzlich kann man sich eine Schnittstelle zum Kunden denken, die natürlich personalisiert und nutzerfreundlich sein muss. Dem konkreten Einsatzgebiet sind dabei keine Grenzen gesetzt. Software lässt sich direkt im Internet zukaufen oder mieten, kann aber auch selbst erstellt werden. Ein Bezug zur Hardware ist dabei wirklich kaum noch vorhanden. Man kann sich also nicht irgendeinen konkreten Server bei Google mieten. Diesen indirekten Zugriff auf konkrete Hardware durch ein Software-Framework vollziehen die sogenannten Cloud-Dienste. Die bekanntesten Cloud-Dienste sind folgende: 왘

Google App Engine

왘

Amazon AWS (Amazon Web Services)

왘

Microsoft Azure

왘

Ubuntu One

왘

Ubuntu Enterprice Cloud

왘

VMware vSphere

왘

Apple iWork.com

왘

Apple MobileMe

Jeder Anbieter hat dabei seine eigene Philosophie und meist einen Satz an gängigen Programmiersprachen, die unterstützt werden. Nun aber noch einmal zurück zu der gewaltigen Datenflut aus dem Weltall und der Sonde namens Gaia: Die Firma Server Labs (http://www.theserverlabs.com/) hat den Auftrag angenommen und will das Gaia-Projekt mit Hilfe von AWS in die Cloud bringen: http://aws.amazon.com/de/. Gaia Gaia wird in der griechischen Mythologie als »die Erdmutter« bezeichnet. Sie gehört zu den Urgottheiten. Sie wird bereits in den Homerischen Epen erwähnt und reicht wahrscheinlich bis weit in die Zeit einer matriarchalischen, indogermanischen Frühkultur zurück. Sie ist die Göttin der Erde und der Fruchtbarkeit, aber auch die Herrin über die Toten und die Unterwelt. Denn die Frühmenschen erkannten bereits: Von der Erde kommen wir, und zu ihr kehren wir auch wieder zurück.

504

Cloud Computing

An dieser Stelle haben wir leider keine Daten aus dem All, um die Thematik programmiertechnisch abzurunden, daher holen wir etwas weiter aus und befassen uns mit einer Simulation, die zwar nichts mit Cloud, aber mit dem Thema Gaia zu tun hat. Praxis: »Gänseblümchen« – Daisyworld Mit dem Namen Gaia ist seit den 60er Jahren auch eine Hypothese verbunden, die uns heute bereits wieder etwas seltsam anmutet: die Idee der Erde als Gesamtorganismus. Nachdem man sich ausgiebig mit Regelkreisen und Kybernetik auseinandergesetzt hatte, kamen der Mediziner und Biophysiker James Lovelock und eine Mikrobiologin auf die Idee von der Erde als allumfassendem Regelsystem. Grundlage war die Überlegung, dass die Strahlung der Sonne eigentlich über die Jahrmilliarden stetig zunehmen und alles vertrocknen müsste. Zudem müssten die Meere längst total versalzen sein und der Sauerstoff längst alles in Rost verwandelt haben und verschwunden sein. Dass dem nicht so ist, legt die Vermutung nahe, dass die Erde als Lebensraum sich selbst so steuert und erneuert, dass das Leben auf ihr halbwegs erträglich bleibt. 1983 veröffentlichen Andrew Watson und James Lovelock das Modell Daisyworld, um diese Idee zu beweisen. Daisyworld ist ein hypothetischer Planet, der unsere Erde in vereinfachter Form darstellt. Dieser Planet umkreist eine Sonne und ist belebt. Bei seinen Bewohnern handelt es sich um weiße und schwarze Gänseblümchen (englisch Daisy = Gänseblümchen). Beide Gänseblümchenarten haben die gleichen Wachstumsraten und leben auch gleich lange. Sie unterscheiden sich nur darin, dass sie durch ihre unterschiedliche Blütenfarbe das Licht anders reflektieren. Weiße Gänseblümchen werfen das Sonnenlicht zurück, und die Erde kühlt sich ab. Schwarze absorbieren das Sonnenlicht und heizen die Erde auf. Für beide gibt es die gleiche optimale Wachstumstemperatur. Eine Überhitzung beziehungsweise Unterkühlung wird also beide Lebensformen gleichermaßen schädigen. Die Frage ist: Kommt es aufgrund dieser Konstellation zu einem Gleichgewicht im Regelkreis, oder kippt das System? Eine genaue Erläuterung des Daisyworld-Modells finden Sie unter der URL http:// web.archive.org/web/20080209000536/www.carleton.edu/departments/geol/Dave STELLA/Daisyworld/daisyworld_model.htm. Eine Version in JavaScript gibt es auf dieser Webseite: http://gingerbooth.com/ courseware/pages/demosdaisy.html#daisy. Das entsprechende Programm »Gänseblümchen« in Java enthält die Buch-DVD unter Software zum Buch/Kap12/Gänseblümchen.

505

12.1

12


Die Jar-Datei lässt sich starten über Java -jar Gänseblume.jar

Das Verzeichnis Gänseblümchen enthält den Quellcode als Eclipse-Projekt. Es handelt sich um eine etwas differenziertere Version, in der es Mutationen und eine zufallsgesteuerte Düngung gibt. Folgende Parameter werden bei der Simulation berücksichtigt: 왘

Abkühlrate: Die Gänseblümchen haben einen Wert, den tempFactor, der angibt, wie stark sie die Temperatur beeinflussen. Das betrifft sie selbst und die sie bis in die dritte Reihe umgebenden 48 Zellen.

왘

Mutation: Wählt man Edit 폷 Einstellungen und ändert die 0, werden per Zufall Mutationen erzeugt.

왘

Der tempFactor der jungen Gänseblümchen wird auf eine Zahl zwischen –5 und 5 eingestellt (ohne die 0). Die Lieblingstemperatur erhält einen Zufallswert zwischen –3 und 3, und ein Zufallswert für die bevorzugte Düngung wird gewählt.

왘

Lieblingstemperatur: Für jedes Gänseblümchen gibt es eine Lieblingstemperatur. Entspricht sie der Umgebungstemperatur, so lebt das Gänseblümchen länger und produziert den meisten Samen. Die daraus wachsenden Nachkommen haben die gleiche Lieblingstemperatur, es sei denn, sie wurden durch eine Mutation verändert.

왘

Düngung: Die Düngung lässt sich mit dem Mauscursor verteilen. Hierzu kann man eine Düngerart über Checkboxen auswählen. Dünger werden nie vollständig verbraucht, sie ändern sich nur entsprechend der Einstellung über Edit 폷 Einstellungen 폷 Dünger von einer Düngerart in die andere.

Dünger erhöht die Lebenszeit und außerdem die Vermehrungsrate eines Gänseblümchens. Nach dem Start des Programms verteilt man per Zufallsfunktion mit Edit 폷 Säe Blumensamen Samen über den Gänseblümchen-Planeten. Vor dem Säen kann man die Eigenschaften der Gänseblümchen über eine Dialogbox verändern. Man kann auch die Chaos-Funktion nutzen und damit Samen mit zufällig ausgewählten Eigenschaften säen. Wie man sehr schnell erkennt, bildet sich bald ein recht stabiler Zustand heraus, und die Temperatur bleibt relativ konstant. Die Daisyworld-Simulation zeigt nicht nur, dass sich Lebensräume aufgrund von kybernetischen Mechanismen selbst steuern, sie spielt auch in der Software-

506

Cloud – wichtiger Baustein der Informationszukunft

geschichte eine Rolle. Man hat sie in verschiedenen Formen bei der Entwicklung von Computerspielen benutzt, unter anderem in dem Spiel SimEarth von der Firma Maxis.

12.2

Cloud – wichtiger Baustein der Informationszukunft

Cloud Computing lebt von der Idee, dass Rechner bald überall verfügbar sein werden. Wie kann man sich das vorstellen? Während embedded computing den Rechner überall integriert – am Ende gar in unserer Kleidung –, wird die OLED-Technik die Visualisierung derart revolutionieren, dass Computerdisplays omnipräsent werden. OLED wird uns zunächst einmal Displays bescheren, die wie Papier von außen und nicht mehr von innen beleuchtet werden. Wir werden sie draußen bei hellstem Sonnenlicht nutzen können. Das ständig verfügbare Display bringt uns den ständig verfügbaren Cloud-Rechner aus dem Internet. Aber OLED kann noch mehr: Unser gesamtes Umfeld wird zur Bildschirmanzeige. Man kann sich das vorstellen, als wären die Wände eines Raumes nicht mehr tapeziert, sondern mit einem papierdünnen OLED-Display beklebt. Nachts oder in der Dämmerung kann diese Wandbeschichtung gleichmäßig leuchten und damit eine Helligkeit verbreiten, die keine grellen Lichtquellen mehr kennt. Hätten wir es stattdessen lieber dunkel, könnten wir unser Zimmer auch in einen glitzernden Nachthimmel verwandeln – nicht etwa in irgendeinen, auch die Echtzeitanzeige des Himmels über Honolulu wäre möglich oder in Echtzeit der Himmel über dem Krater Tycho auf dem Mond. Alternativ dazu wäre natürlich auch ein Strandblick nach Sonnenaufgang möglich, nur nicht als tote Fototapete, sondern als Blick in die bewegte Wirklichkeit. Wir können statt in einem tristen Bürozimmer unsere Arbeit auf dem Sunset Boulevard machen und Touristen an uns vorbeiflanieren lassen, die unsere virtuelle Anwesenheit nicht einmal ahnen. Für die Anzeige von Daten sind keine separaten Monitore mehr nötig, wir rufen sie einfach in unserer multivisuellen Umgebung auf, indem wir per Geste mit den Fingern ein Datenfeld an der Wand, auf dem Wandschrank oder der Kühlschranktür aufziehen. Somit vermischen sich Umwelt und Arbeitsplatz endgültig. Und während im Schlafzimmer die Ehefrau im Bett liegend an der Decke ihren Krimi durchblättert, kann der Gatte noch einmal die letzten Zahlen der Bilanz abgleichen oder den Kurs des erfolgreichen OLED-Produzenten von der Deutschen Börse visualisieren lassen.

507

12.2

12


Mit Schrecken mag man sich die Informationsflut dieses kommenden Zeitalters, die auf die Menschen einstürzen wird, ausmalen. Aber das muss nicht sein. Werbung, die einen Schritt für Schritt und sogar bis auf die Toilette verfolgt, wird schließlich vom Menschen gemacht. Sie ist kein Muss, auch wenn uns die Werbemanager das einreden wollen. Eine Umwelt aus Displays könnte uns genauso gut rauschende Wälder, grüne Wiesen und Meereslagunen bescheren, in denen sich unser Gemüt erholen kann und sich unsere Phobien kurieren ließen. Wahrscheinlich wird es jedoch so kommen, dass man kostenlos mit Konsumanreizen bombardiert wird und nur gegen einen ansehnlichen Betrag Ruhe und Entspannung genießen darf. Eine verkehrte Welt zeichnet sich ab: Ein omnipräsenter Informationssumpf schafft das neue Bedürfnis der Informationsfreiheit, die natürlich bezahlt werden darf. Cloud Computing wird in diesem allgegenwärtigen Chaos dafür sorgen, dass wir wenigstens die für uns wichtigen Informationen auf Basis einer immer gleichen Bedienung und unseres individuellen Desktops so halbwegs werden steuern und beherrschen können.

12.3

Noch mehr Spaß: Ubuntu One

Ubuntu bietet auf Betriebssystem-Basis ebenfalls Cloud-Dienste an. Da ist einmal Ubuntu One. Darunter verstehen die Ubuntu-Leute den Zugriff auf Speicherplatz auf Servern und die Möglichkeit, lokale Dateien mit den Dateien auf dem Server abzugleichen. Daher nennt man solche Systeme Filehosting-Systeme. Sie bieten den Vorteil einer Art Zwischenspeicher, den man von verschiedenen Rechnern aus nutzen kann. Ein Außendienstmitarbeiter hat sich beispielsweise am Wochenende Notizen auf einem privaten Rechner gemacht und diese über Ubuntu One für seine anderen Rechner freigegeben – wobei sich der Serverzugriff bei ihm einfach in Form eines Verzeichnisses darstellt, in das er seine Dateien lediglich hineinzuschieben braucht. Wenn er nun am nächsten Arbeitstag im Büro seinen Ubuntu-Rechner startet, wird die aktuelle Datei mit den frischen Notizen auf seine Platte übertragen und angezeigt. Genauso ist es mit seinem tragbaren Rechner beim Kunden. Also durchaus eine praktische Sache, die bereits bei der Installation eines neuen Ubuntu aktiviert werden kann. Zwei Gigabyte Speicherplatz sind kostenlos, wer mehr möchte, kann 50 Gigabyte ordern, die allerdings monatlich 10 $ kosten. Aber Mark Shuttleworth, der Ubuntu-Gründer geht noch einen Schritt weiter: Er bietet auch die Desktop-Virtualisierung per Cloud-Dienst an. Dazu nutzt Ubuntu 508

Lesen Sie weiter

allerdings Amazons Elastic Compute, kurz EC2 genannt. Nähere Informationen zum Ubuntu-Cloud-Projekt erfahren Sie über die Webadresse http://www.ubuntu .com/cloud.

Abbildung 12.18

Das Ubuntu-One-Verzeichnis

Die Sache ist nicht ganz so trivial wie die gezeigten Online-Rechner eyeOS und icloud. Außerdem werden – je nachdem, wie man das System nutzen möchte – Gebühren fällig. Eine Anleitung, wie man einen Cloud-Desktop einrichtet, finden Sie hier: https://help.ubuntu.com/community/EC2StartersGuide. »Große Computer kosten ein Vermögen, kleine nur den Verstand.« – Anonymus

12.4

Lesen Sie weiter


Beschreibung

http://de.wikipedia.org/wiki/Cloud_Compu- Wikipedia-Seite zu Cloud Computing ting http://www.eclipse.org/geclipse/resources/ videos/20080920_gEclipse_and_AWS.php

Anleitungsfilm zu Cloud mit Eclipse

509

12.4

12


URL

Beschreibung

http://aws.amazon.com/de/

AWS-Homepage

http://mashable.com/2007/08/22/web-os/

Übersicht über Web-OS-Systeme

http://www.archive.org/web/web.php

Webseiten-Archiv

http://www.gaiatheory.org/

Seite zur Gaia-Theorie

http://web.archive.org/web/ Gaia-Modell im Internet 20080209000536/ www.carleton.edu/ departments/geol/ DaveSTELLA/Daisyworld/ daisyworld_model.htm https://www.iwork.com/signin/de/

rudimentäre Cloud Services von Apple

http://aws.amazon.com/de/

Homepage zu Amazon Web Services

http://hoster-toaster.de/cloud-computing/

Übersicht über Cloud-Anbieter

Webseiten speziell zu Cloud Computer/OS URL

Beschreibung

http://www.icloud.com

Cloud OS aus HTML2 mit JavaScript/ Java

http://www.silveos.com/

Windows-ähnliches Cloud OS in Silverlight programmiert

http://sourceforge.net/projects/ windows4all/

Quellcode des windows4all-SilverlightSystems

http://eyeos.com/

reines HTML2 -Cloud OS

http://www.jolicloud.com

Cloud OS für Netbooks

http://www.thinkgos.com/

Googles Chrome OS ???

http://xcerion.com/

Homepage von Xcerion

http://www.um.es/fem/EjsWiki/ pmwiki.php

Simulationen in Java

http://eyeos-apps.org/content/show.php/ eyeDesigner+Prototype+-+Windows? content=117916

eyeOS-Designer – Prototyp

http://gosuniverse.ning.com/

gOS-Seite

510

Lesen Sie weiter

Literatur zum Kapitel Wieske, Lothar: Cloud Computing – Vorbereiten und Einsetzen: Einführung, Praxis, Perspektiven. dpunkt Verlag 2010. Carr, Nicholas, Engel, Reinhard: The Big Switch: Der große Wandel. Die Vernetzung der Welt von Edison bis Google. mitp-Verlag 2008. Sirtl, Holger: Cloud Computing mit der Windows Azure Platform: Softwareentwicklung. Microsoft Press 2009. Baun, Christian u.a.: Cloud Computing: Web-basierte dynamische IT-Services (Informatik Im Fokus). Springer Verlag. Berlin 2009. Köhler-Schute, Christiana: Software as a Service: SaaS: Strategien, Konzepte, Lösungen und juristische Rahmenbedingungen. Ks-Energy-Verlag 2009.

511

12.4

»The best way to predict the future is to invent it.« – »Der beste Weg, die Zukunft vorherzusagen, ist, sie zu erfinden.« – Alan Kay Die Bezeichnung »Elektronenhirn«, die sich zwar nicht wirklich durchgesetzt, aber auch nicht überholt hat, verrät so einiges über die heimlichen Hoffnungen der Computerbauer – bei Babbage angefangen bis heute.

13

Denkmaschine

2000

2020

2035

2050

2080

3000

rechnende Zellen Licht/Quantencomputer Biocomputer denkende Maschinen

künstliches Bewusstsein

13.1

Das Phantom an der Börse

06.05.2010, Kurssturz an der Wall Street: »Ein zynischer Regisseur hätte sich das Drehbuch nicht besser ausdenken können. Es ist Donnerstagnachmittag an der Wall Street in New York, als plötzlich Bilder von Krawallen aus Griechenland über die Monitore des Börsenfernsehsenders CNBC flimmern. Die schlechten Nachrichten lösen heftige Verkäufe aus. Der Dow Jones stürzt binnen weniger Minuten um 300 Punkte ab. Doch das ist erst der Anfang. Fassungslos müssen die Händler mit anse-

513

13

Denkmaschine

hen, wie das Börsenbarometer binnen fünf Minuten um knapp 1000 Zähler abstürzt – der nach Punkten größte Tageseinbruch der Geschichte. Das gespenstige Schauspiel ist nach etwa 20 Minuten vorbei. Zu diesem Zeitpunkt sind allein beim Dow Jones Werte von 350 Milliarden Dollar vernichtet worden – ebenso viel, wie Griechenland in einem Jahr an Waren und Dienstleistungen produziert. Auf den rasanten Absturz folgt eine fast ebenso schnelle Erholung. Am Ende des verrückten Börsentages bleibt ein Minus von 3,2 Prozent zurück und bei vielen Händlern das mulmige Gefühl, dass irgendetwas gründlich schiefgelaufen ist.« – Die Welt, 07.05.2010 Erst hieß es, ein kleines Maklerbüro hätte sich um ein paar Nullen vertan, dann was es ein Hacker und schließlich einfach nur noch ein Computerfehler. Zwischendrin hörte man immer mal wieder flüstern: »Es war der Laplacesche Dämon!« Nie gehört! Was es damit auf sich hat, war so einfach nicht zu verstehen. Der Laplacesche Dämon ist ein Gedankenexperiment zu einem allwissenden Wesen, das seine Allwissenheit dadurch erlangt, dass es aus dem gegebenen Zustand des Universums alle kommenden Zustände errechnen kann. »Wir müssen also den gegenwärtigen Zustand des Universums als Folge eines früheren Zustandes ansehen und als Ursache des Zustandes, der danach kommt. Eine Intelligenz, die in einem gegebenen Augenblick alle Kräfte kennte, mit denen die Welt begabt ist, und die gegenwärtige Lage der Gebilde, die sie zusammensetzen, und die überdies umfassend genug wäre, diese Kenntnisse der Analyse zu unterwerfen, würde in der gleichen Formel die Bewegungen der größten Himmelskörper und die des leichtesten Atoms einbegreifen. Nichts wäre für sie ungewiss, Zukunft und Vergangenheit lägen klar vor ihren Augen.« – O. Höfling, Physik Band II In der Tat hat die Computerisierung des Börsenhandels etwas von einem Laplaceschen Dämon an sich. Auch hier geht es um die Zukunft und die Vorhersage derselben. Pierre-Simon Laplace war ein hochbegabter französischer Astronom und Physiker, der auf vielen wissenschaftlichen Gebieten außerordentlich erfolgreich war und die Theorien Newtons in seinem Hauptwerk zur Himmelsmechanik und der Planetenbewegung vervollständigte. Er war unter Napoleon kurze Zeit französischer Innenminister, verlangte später mit Marschall Ney Napoleons Abdankung und wurde unter König Ludwig XVIII. zum Marquis ernannt. Er befasste sich zwar eingehend mit der Wahrscheinlichkeitsrechnung, sah sie jedoch nur als Mittel, um zu Ergebnissen zu kommen, wenn die erforderlichen

514

Das Phantom an der Börse

Parameter nicht alle bekannt waren. An echten Zufall glaubte er nicht und hielt die Welt für vollständig berechenbar. Diese Überlegungen bezeichnete man später als den Laplaceschen Dämon. Bis zur Suche nach der Weltformel, die am intensivsten in den 70er Jahren des vorigen Jahrhunderts betrieben wurde, war der Laplacesche Dämon ein wichtiger Teil physikalischer und philosophischer Überlegungen. Es ist nicht nur entscheidend, was man benötigt, um die Zukunft vorausberechnen zu können, sondern auch, was passiert, wenn man es kann, oder schon, wenn man es nur glaubt zu können. Die errechneten Ergebnisse werden zur Grundlage von Handlungen, z. B. an der Börse (Aktienkäufe). Diese wiederum beeinflussen die Zukunft und erfordern neue Berechnungen, das kann sehr schnell zum Hochschaukeln von Reaktion und Gegenreaktion führen. Inzwischen ist man aufgrund der umfangreichen Ausarbeitungen der Quantenmechanik, der Heisenbergschen Unschärferelation und der Gödelschen Unvollständigkeitssätze von der Überzeugung der vollständigen Berechenbarkeit des Universums und der Existenz einer Weltformel abgekommen. Für einige unbelehrbare Deterministen1 und für Überlegungen zum Bau von Hypercomputern ist sie trotzdem noch von Belang. Schließlich geht die Leistungssteigerung bei Computern unaufhaltsam weiter. Die Informatik macht sich darüber Gedanken, wie man Programme schreiben könnte, die intelligent sind. Welche Auswirkungen jedoch der Bau von künstlichen Superhirnen haben müsste, darüber möchte man sich im Grunde keine Gedanken machen. Das Thema gehört zwar zum Standardrepertoire der Science-Fiction-Literatur, ernsthaft erörtert wird es jedoch selten. Die eigentliche Gefahr ist deshalb auch – wie in der Literatur schon oft heraufbeschworen – die völlig unbewusste und ungewollte Schöpfung eines solchen Hyperverstandes. Oft sieht man die Gefahr in der globalen Vernetzung, weil dabei Gebilde entstehen, die weder zu überblicken noch zu steuern sind. Gehen wir einfach einmal davon aus, es gäbe so etwas wie eine Laplacesche Dämon-Maschine, so wäre sie im Bereich des Börsen- und des Finanzwesens von eminentem Wert. Da in diesem Bereich ständig Hard- und Software auf Kursvorhersagen optimiert werden, könnte es sein, dass so eine Art eingeschränkter Laplacescher Dämon entstanden ist, der sozusagen ungewollt geschaffen nun auf den Finanzmärkten sein Unwesen treibt. Fiktiv, aber eindeutig ein Leckerbissen für Science-Fiction-Horrorfans. 1 Menschen, die an die formale Berechenbarkeit der Welt glauben

515

13.1

13

Denkmaschine

Viel interessanter ist es zu überlegen, was für Existenzprobleme so ein hypothetischer Laplacescher Dämon hätte. Wollte man alles berechnen, um eine absolut sichere Zukunftsvorhersage machen zu können, stößt man bald auf eine interessante Rekursion. Da ein solcher Dämon Teil der Welt ist, deren Zukunft er zu berechnen hat, muss er nach Abschluss seiner Berechnung einen weiteren Rechengang durchführen, denn die Berechnung liefert ein unvorhergesehenes Ergebnis, sonst hätte er nicht zu rechnen brauchen. Solche Ergebnisse verändern aber unweigerlich die Zukunft, seine Berechnung ist damit falsch, und er muss neu rechnen und dabei das Ergebnis der ersten Berechnung mit einfließen lassen. Da er jetzt ein anderes Ergebnis erhält, ist auch dieses falsch, weil seine neuerliche Berechnung ebenfalls nicht Grundlage seiner Berechnung war. Das klingt sehr nach Gummiband, ist aber für einen allwissenden Laplaceschen Dämon ein völlig unlösbares Problem. Zumal er durch seinen Energiebedarf während der Rechnerei das Weltengefüge beeinflusst. Da er aber nie wissen kann, wie lange er jeweils rechnet, kann er auch seinen Einfluss nicht vorwegschätzen und wird die Frage nach der exakten Zukunft also nie beantworten können. Dass ein ähnliches Problem an den Börsen auftreten kann, ist naheliegend, zumal die verwendeten Programme durch ihre Handelsstrategien den Handel selbst beeinflussen. Dieses Beispiel zeigt uns überdeutlich, dass eine Rechenmaschine zwar sehr gut den Kassenzettel im Kaufhaus aufaddieren kann, aber enorme Probleme bekommt, sobald sie denken soll. Denken ist eben doch kein Rechenvorgang, sondern hat eher etwas mit Mutmaßungen zu tun. Wir denken eben nur ungefähr und nicht genau, umschiffen dadurch aber all die Paradoxien, die beim exakten Rechnen auftreten. Roger Penrose hat dies sehr gekonnt in folgendem Satz ausgedrückt: »Wenn es eine Frage gibt, die wir mathematisch korrekt darstellen können, beispielsweise mit den Mitteln der formalen Logik, und wenn es wenigstens eine korrekte Antwort auf diese Frage gibt, die sich auch aufschreiben lässt, es aber keinen Weg gibt, aufgrund der Frage und irgendwelcher Informationen die Antwort zu errechnen, der Mensch aber diese Antwort geben kann, so ist er nicht berechenbar, und keine Maschine wird ihn je ersetzen können.« Roger Penrose Roger Penrose wurde am 8. August 1931 in Colchester, Essex, geboren und ist Professor für Physik und Mathematik. In zahlreichen Forschungsarbeiten und Büchern hat er sich mit dem Problem des Bewusstseins und der Simulation von Denkvorgängen befasst.

516

Quantenmechanik

Die Quintessenz von Penrose‘ Überlegungen ist die, dass unser Bewusstsein zwar natürlichen Ursprungs ist, jedoch auf der Grenzfläche zwischen Quanten- und klassischer Physik angesiedelt ist und Quanteneffekte für seine Existenz benötigt. Da solche Effekte noch nicht völlig erforscht und auch noch nicht ganz verstanden sind, bleibt das Bewusstsein vorerst ein Geheimnis. Die Hoffung der Physiker liegt nun darin, Computer zu bauen, die Quanteneffekte zum Rechnen nutzen, und mit einem solchen Computer auch die Geheimnisse des Geistes zu lüften. Die Idee von Penrose wird jedoch nicht von allen anerkannt. Insbesondere bemängelt man daran, dass auch der Quantencomputer nur eine deterministische Turingmaschine ist, also den gleichen Problemen unterliegt wie ein normaler Computer. Er kann lediglich bestimmte Probleme schneller lösen als heutige Rechner. Der wichtigste Unterschied zwischen den beiden Rechnerarten ist der, dass ein Quantencomputer keine eindeutigen Bits kennt. Während bei einem makroskopischen Rechner ein Bit entweder 1 oder 0 ist, ist es bei einem Quantenrechner 1 oder 0 oder ein bisschen was von beidem. Deshalb bezeichnet man die Bits des Quantenrechners auch als Qbits, als Quantenbits. »Im Anfang war der Computer, und er war nicht von Gott.« – H. R. Wieland

13.2

Quantenmechanik

Unter einem Quantencomputer versteht man einen Elektronenrechner, der sich quantenmechanische Effekte zunutze macht. Die Quantenmechanik kennt eine ganze Reihe Effekte, die der klassischen Mechanik fremd sind. Das liegt einfach daran, dass die kleinsten Bestandteile der Materie sich völlig anders verhalten, als die aus ihnen aufgebauten makroskopischen Objekte. Atome sind eben doch keine kleinen Kügelchen, wie wir sie uns vorstellen, sondern etwas ganz anderes. Aus der Quantenmechanik ergeben sich etliche Sachverhalte, die für die Konstruktion eines Quantenrechners von eminenter Bedeutung sind.

13.2.1

Quantenverschränkung

Die Quantenverschränkung besagt, dass die Eigenschaften eines Teilchenpaars nur als Gesamtes gesehen werden können. Der Drehimpuls (Spin) eines Atom-

517

13.2

13

Denkmaschine

paares hebt sich auf. Ein Atom hat den Spin +I/2, das andere –1/2. Welches jedoch welchen Spin hat, kann man erst sagen, wenn man einen Spin gemessen hat, dann hat das andere Atom nämlich den entgegengesetzten. Das gilt selbst dann, wenn die Atome über kosmische Distanzen getrennt sind. Man hat versucht, damit Information überlichtschnell zu übermitteln, was jedoch problematisch ist. Kennt man den Spin eines Atompaares, so kann man das Atom nur herkömmlich übertragen (unter Lichtgeschwindigkeit). Ist das Atom jedoch schon beim Empfänger, bevor man den Spin misst, kann der Empfänger es nicht auswerten, weil er nicht weiß, was für ein Spin mein Atom hat, und ich nicht weiß, was für ein Spin seines. Ich muss ihm also mitteilen, die Information für ihn steckt im dritten, fünften, zehnten Atom, und das geht höchstens mit Lichtgeschwindigkeit. Demnach sind auch superschnelle Quantenrechner illusorisch.

13.2.2

Superposition

Nicht mit ihrer Umgebung verschränkte Teilchen – man nennt sie der Einfachheit halber isolierte Teilchen – besitzen keine genau definierbare Position oder keinen genau definierbaren Zustand. Sie sind verschmiert, wie man sagt, oder mit der bestimmten Wahrscheinlichkeit an einer bestimmten Position. Ihre Beobachtung hebt diese Unbestimmtheit auf – eine Eigenschaft, deren Ursache noch nicht eindeutig geklärt ist. In jedem Fall aber hängt sie mit dem Phänomen des echten Zufalls im Mikrokosmos zusammen. Es gibt noch eine ganze Reihe anderer quantenmechanischer Effekte, die jedoch für den Bau von Quantenrechnern nicht von so vorrangiger Bedeutung sind wie die Superposition und die Verschränkung.

13.2.3 Qbits Qbits können zunächst einmal ein genau definiertes klassisches Bit enthalten, sie können aber auch undefiniert sein. Diese Eigenschaft ist jedoch erst nutzbar, wenn sie mit anderen Qbits verschränkt sind. Wie bei der klassischen Informatik kennt die Quanteninformatik auch Byts, in diesem Falle Qbytes. Ein Qbyte besteht aus acht verschränkten Qbits. Im Gegensatz zum klassischen Byte kann es nicht nur eine konkrete Zahl zwischen 0 und 255 enthalten, sondern alle gleichzeitig. Eine Operation auf dieses Qbyte wäre demnach eine Berechnung an allen Zahlen von 0 bis 255 – sicherlich mit der Problematik, dass man nicht am Ende alle Ergebnisse wie aus einer Liste auslesen kann. Zugriffe auf das Qbyte werden immer ein zufälliges der 256 Ergebnisse liefern. Es wären also weitere Operationen nötig, um das gewünschte Ergebnis zu erhalten.

518

Quantenmechanik

Bei aller Euphorie für den Quantenrechner sollte man nicht vergessen, dass es in der Geschichte der Informatik schon Tausende von Rechnerarchitekturen gab, die sich fast alle als nur bedingt brauchbar herausgestellt haben. Der Versuch, ein neues Computermodell von vornherein zu favorisieren, dürfte also kaum erfolgversprechend sein. Anderseits werden wir bei weiterer Verkleinerung der Verschaltungen in den Prozessoren ohnehin früher oder später mit Quanteneffekten konfrontiert, also kann es durchaus Sinn machen, sich diese Effekte schon einmal anzusehen. Praxis: Quantenrechner simulieren Aktuell haben wir natürlich noch keinen Quantenrechner zur Verfügung. Quantenrechner sind aber genauso zu den Universalrechnern zu zählen wie Turingmaschinen. Daher können sie von einer anderen Turingmaschine, eben dem PC, simuliert werden. Die Quantenrechner-Simulation finden Sie im Internet unter http://jquantum.sourceforge.net/index.html. Auf der DVD liegt sie in diesem Verzeichnis: Software zum Buch\kap13\jQuantum. Die Datei jQuantum-2.3.1.jar ist die lauffähige Java-Datei. Sie wird wie üblich gestartet mit java -jar jQuantum-2.3.1.jar

Im gleichen Verzeichnis liegen die Dokumentation, gepackte Beispieldateien und der Quellcode entsprechend der von JQuantum genutzten GNU General Public License. Wenn die Jar-Datei gestartet ist, öffnet sich ein detaillierter Dialog mit der Simulation eines Quantenrechners. Im unteren Teil befinden sich rechenfeldartig die beiden Register x und y, darüber gibt es ein weißes Feld, um die Schaltungen aufzubauen. Wir wollen ein AND-Gatter aufbauen, eine der einfachsten Grundschaltungen. Dazu müssen wir erst einmal die Register einrichten. Dazu gibt es die Schaltfläche mit dem ϕ. Ein kleiner Dialog öffnet sich, in dem wir 3 x-Register, 0 y-Register und 0 als Anfangszustand einstellen. Eine Registerdarstellung aus 8 schwarzen Blöcken wird angezeigt. Wenn wir mit der Maus darübergleiten, sehen wir, dass die binären Zustände der Qbits dort festgehalten sind. Wie wir vielleicht schon wissen, sieht die AND-Funktion wie in der folgenden Tabelle aus. AND besagt, dass eine Aussage nur dann wahr ist, wenn beide Teilaussagen wahr sind. Also, ist x1 wahr und x2 wahr, ist auch x1 AND x2 wahr. Ansonsten ist x3 falsch.

519

13.2

13

Denkmaschine

x1

x2

x3 ← x1 Λ x2

0

0

0

0

1

0

1

0

0

1

1

1

Tabelle 13.1

Die AND-Funktion

Was wir bis jetzt im Simulator sehen, ist der Zustand in der ersten Tabellenzeile: Alle Qbits sind auf 0, was in der binären Denkweise für falsch steht. Wir setzen die ersten beiden mal auf 1, was man mit der ersten quadratischen Schaltfläche machen kann, auf der die 1 und die 0 zu sehen sind. Da man von rechts zählt, werden die beiden rechten Schaltflächen im Anfangszustands-Dialog angeklickt. Was wir benötigen, um die AND-Operation auszuführen, ist das Toffoli-Gatter. Es befindet sich etwa in der Mitte der Schaltflächen. Natürlich sind die Kontroll-Qbits 1 und 2 und das Ziel-Qbit die Nummer 3. Und das Ganze für das x-Register. Das Gatter wird eingezeichnet. Nun brauchen wir nur noch den Rechner arbeiten zu lassen. Dazu klicken wir auf einen der nach rechts weisenden grünen Pfeile. Der eine ist zwar der Einzelschritt-Pfeil, doch das spielt bei diesem Gatter keine Rolle, da es nur einen Arbeitsschritt kennt. Das rote Quadrat ist nun ganz nach rechts gesprungen. Wenn wir die Maus darüberhalten, sehen wir, dass es für die 1 1 1 steht, also die richtige Lösung für 1 AND 1 anzeigt. Wenn wir die Initialisierung der Qbits ändern und rechnen lassen, bekommen wir jeweils die 0 in x3, wie es sein soll. Das war ein einfaches Beispiel. In der Datei QuantumCircuits-Examples-2.3.zip finden sich zahlreiche weitere Beispiele, die man einfach über Datei 폷 Quantenschaltung laden ausprobieren kann.

13.3

Von der Natur lernen: neuronale Netzwerke und KI

Eine andere Überlegung geht davon aus, dass man den Aufbau des Gehirns simulieren muss, wenn man seine Fähigkeiten kopieren will. Gehirne sind nun aber mal ganz anders aufgebaut als heutige Computer. Während ein Computer seine Leistung aus der Arbeit eines rechnenden Prozessors bezieht, besteht ein Gehirn aus der Verknüpfung von Abermilliarden rechnenden Zellen.

520


So ist es auch nicht weiter verwunderlich, dass man die Leistung beider »Rechner« nicht so einfach vergleichen kann. Sie arbeiten nach völlig verschiedenen Prinzipien. Ein Gehirn kann zwar rechnen, also einen Rechner simulieren, ein Rechner kann jedoch kein Gehirn simulieren. Oder wenigstens wissen wir nicht, wie wir ihn dazu bringen könnten, dass er es kann. Diese Diskrepanz zwischen Computer und Gehirn beschäftigte bereits die ersten Computerkonstrukteure und inspirierte sie dazu, den Assoziativspeicher zu bauen. Daten aus herkömmlichen Speichern zu lesen ist, wie einen Ordner aus dem Aktenschrank zu ziehen. Wenn man nicht genau weiß, welche Ordnernummer man benötigt, muss man alle Ordner vom ersten bis zum letzten aufschlagen. Menschen suchen assoziativ, sie schließen vom Inhalt des aus der Mitte gegriffenen Ordners auf die vorigen und nächsten Ordner und finden den gesuchten Ordner schneller.

13.3.1

Das erste neuronale Netz

Konrad Zuse machte sich bereits 1943 Gedanken, wie man einen Datenspeicher bauen müsste, damit man assoziativ darin suchen kann. Doch das Gehirn besitzt nicht nur Speicherfähigkeit. Es kann außerdem gespeicherte Inhalte miteinander verknüpfen und daraus Schlüsse ziehen. Diese Fähigkeit faszinierte ebenfalls 1943 die beiden Mathematiker Warren McCulloch und Walter Pitts. Sie überlegten sich ein Modell der menschlichen Nervenzelle. An mehreren Eingängen sollten Signale anliegen. Überstieg die Summe dieser Signale einen bestimmten Grenzwert (Bias), so wechselte die künstliche Nervenzelle ihren inneren Zustand von false nach true. Der innere Zustand true bewirkte ein Signal am Ausgang. McCulloch und Pitts konnten zeigen, dass durch Kombinieren solcher künstlicher Neuronen die einfachen Funktionen der Aussagenlogik, wie AND, OR und NOT, realisiert werden konnten. Damit hatten die künstlichen neuronalen Netze Eingang in die Informatik gefunden. Für ihre Weiterentwicklung waren die Forschungen des Psychologen Donald O. Hebb von Bedeutung. Nach seiner Hypothese lassen sich hemmende und aktivierende Wirkungen der Synapsen aufgrund der Aktivität berechnen, die von ihnen erwartet wird. Das erste funktionsfähige neuronale Netzwerk erdachte sich schließlich 1957 ein gewisser Frank Rosenblatt, seines Zeichens Psychologe und Informatiker. Seine Idee realisierte er 1958 mit Hilfe einfacher elektrooptischer Bauelemente zu einem Retinamodell, das einfachste Muster erkannte. 1960 erarbeitete er 521

13.3

13

Denkmaschine

außerdem an der Cornell Universität, Ithaca, New York, Computerprogramme für den Mark I. Damit war der Mark I der erste lernfähige Rechner der Welt. Das Buch »Principles of Neurodynamics: Perceptrons and the Theory of Brain Mechanisms«, das Rosenblatt 1962 veröffentlichte, wurde zum ersten Standardwerk in der neuronalen Netzforschung.

13.3.2 Der Streit ums Perceptron In der ersten Euphorie war man tatsächlich der Meinung, einen Weg gefunden zu haben, künstliches Denken zu verwirklichen. Rosenblatts Ansichten fanden jedoch nicht nur Befürworter. Insbesondere ein Professor am Massachusetts Institute of Technology (MIT), namens Marvin Lee Minsky, fühlte sich in seinem Arbeitsgebiet der künstlichen Intelligenz durch Rosenblatts Ideen bedrängt. Schließlich hatte er mit Nathaniel Rochester, Claude Shannon und John McCarthy 1956 auf der Dartmouth Conference den Begriff der künstlichen Intelligenz geprägt und mit Seymour Papert das Labor für Künstliche Intelligenz am MIT gegründet. Minsky zerriss Rosenblatts Ideen in seinen Vorlesungen und griff ihn nicht selten auf polemische Weise auch persönlich an. Während Minsky davon überzeugt war, künstliche Intelligenz durch explizit erstellte Programme erzeugen zu können, bewies Rosenblatts Perceptron offenbar, dass sie sich mit Hilfe eines Lernvorgangs selbst erschaffen konnte, ähnlich wie es offenbar auch beim Menschen abläuft. Man unterschied jetzt zwischen symbolischer (Minsky) und konnektionistischer KI (Rosenblatt), zwei Weltanschauungen, die sich vehement bekämpften. Unter dem Titel »Perceptrons« veröffentlichte Marvin Minsky zusammen mit Seymour Papert beim MIT Press Verlag 1969 ein 258 Seiten umfassendes Buch. Darin holte Minsky zum Rundumschlag gegen die von ihm gehasste Technik aus. Er bewies mathematisch, dass ein Perceptron nicht in der Lage war, das XOR, also das Entweder-oder zu erlernen. Allerdings macht er dabei einen entscheidenden Fehler: Er betrachtete nur Perceptrons, die aus zwei Schichten Neuronen bestanden. Dreischichtige Perceptrons beherrschen das XOR sehr wohl. Man vermutet, dass dies auch Minsky bekannt war. Nur war seiner Meinung nach der Mensch auf dem Weg zu seiner größten wissenschaftlichen Leistung, zur Erschaffung des künstlichen Verstandes. Diesen Erfolg hatte er offenbar für sich reserviert und duldete keine ernsthafte Konkurrenz. Die Idee des Perceptrons wurde durch die Veröffentlichung so geschädigt, dass dafür kaum noch Forschungsgelder flossen, bis 1985 John Hopfield mit einer Veröffentlichung Minsky endgültig widerlegte.

522


Er schuf das Modell des Backpropagation-Netzes, das rückbezüglich lernt, und bewies damit seine Hypothesen. Es kam erneut zu einem Forschungsboom im Bereich der neuronalen Netze. Zahlreiche Anwendungsfelder wurden erobert und zusätzliche Erkenntnisse gewonnen. In großen Forschungsvorhaben wurde inzwischen versucht, ganze Gehirnareale künstlich nachzubauen und zu untersuchen. Allerdings haben sich bis heute die dabei erhofften Erfolge nicht wirklich eingestellt. Praxis I: Neuronales Netz Das wollen wir nun einmal an einem Simulationsprogramm zeigen. Installieren Sie dazu das Programm MemBrain. Sie finden es auf der DVD unter Software zum Buch\Kap13\NNs\MemBrain_Setup.exe Sie müssen die Datei lediglich auf einem Windows-Rechner aufrufen, um die Installation zu starten. Eine umfangreiche Anleitung zu MemBrain findet man übrigens auf der Homepage http://www.neuronalesnetz.de/membrain.html. Weil es eine unregistrierte Version ist, müssen Sie nach dem Start ein wenig warten, bis Sie es nutzen können. Als erstes einfaches Beispiel wollen wir einem neuronalen Netz das Zählen beibringen. Um das nicht zu schwierig zu gestalten, genügt es uns, wenn das Netz lernt, bis 3 zu zählen. Zuerst stellen Sie unter Edit 폷 Default Properties Type auf INPUT, das Gewicht (Weight) unter Edit Link Properties auf 1 und außerdem auf sichtbar (Display Weight). Nun legen Sie zunächst drei Eingangsneuronen an: Insert 폷 New Neurons. Brechen Sie mit der (Esc)-Taste ab, und kontrollieren Sie die Einstellungen an den Neuronen mit einem Doppelklick. Falls etwas nicht stimmt, passen Sie es an. Stellen Sie unter Edit 폷 Default Properties den Type auf OUTPUT, die Activation Function auf BINARY und den Rest wie bei den Eingangsneuronen. Die Pfeile auf den Neuronen zeigen, ob es Eingangs- oder Ausgangsneuronen sind. Jetzt geben wir den Ausgangsneuronen sprechende Namen. Wir nennen sie von links nach rechts: »Eins«, »Zwei« und »Drei«. Ein Doppelklick auf das Neuron genügt, und wir können im Namensfeld unsere Namen eintragen. Jedes Neuron hat einen kleinen Spalt, den wir als Synapse ansehen wollen. Von dort lässt sich mit der Maus eine Verbindung, ein Axon, zu einer Synapse eines anderen Neurons ziehen. Versuchen Sie es. So verbinden Sie alle Eingangs- mit allen Ausgangsneuronen. Die Gewichtung der Verbindungen ist jeweils 1, das ist

523

13.3

13

Denkmaschine

wie keine Gewichtung. Es handelt sich um eine Art Bewertung, wie stark das Signal berücksichtigt werden soll. Die Gewichtung wird vom Programm an die verknüpfenden Linien geschrieben (siehe Abbildung 13.1).

Abbildung 13.1

Nacktes NN-Zählnetzwerk

Dem Netzwerk nun beizubringen, wenn wir an 1 ein Signal anlegen, sollte am Ausgang Eins ein Signal liegen, wäre zu einfach. Es wäre auch kein echtes Zählen. Nein, wir nehmen die binären Zahlen bis 3 und lassen den jeweiligen Ausgang anzeigen, was es ist. 왘

0

000

-> Alle Ausgänge stehen auf 0.

왘

1

001

-> Der Ausgang Eins ist aktiv.

왘

2

010

-> Der Ausgang Zwei ist aktiv.

왘

3

011

-> Der Ausgang Drei ist aktiv.

Die Ausgänge liegen absichtlich umgekehrt zu den Eingängen, damit es nicht heißt, hier wird nur einfach durchgeschleift. Nun gilt es, eine Trainingseinheit für das Netz zusammenzustellen. Dafür nutzt man den Lesson Editor (Tech 폷 Lesson Editor). Mit Names from Net übernehmen wir das Netz in den Editor. Der Lektion kann man einen Namen geben, z. B. »Lektion 1«, und jetzt geht es mit Delete all Pattern und New Pattern los. Oben werden auf allen Neuronen Nullen angezeigt. Das ist bereits unser Zustand, der gelernt werden will. Als Patternname können wir »Null« verwenden. »New Pattern« und »Oben 001« eintra-

524


gen, wobei bei der 6 die 1 steht. Unten kommt bei der 7 die 1 hin, so als würde bei Eins eine Lampe aufleuchten, wenn es richtig sein soll. Im nächsten Pattern kommt jeweils in die Mitte eine 1. Die drei wird binär 011 dargestellt und aufs 9er Neuron wird eine 1 gelegt. Damit ist die Lektion praktisch fertig. Jetzt müssen wir nur noch einen »Lehrer« einstellen, der diese Lektion dem Netzwerk so lange beibringt, bis es sie verstanden hat. Das macht natürlich auch unser Programm, und wir rufen den Teacher auf über Teach 폷 Teacher Manager... Den Teacher nennen wir »Einsbis3« und stellen den Type auf RPROP und weiter: 왘

Repetitions per Lesson: 10

왘

Repetitions per Pattern: 10

Nun gilt es Zählen zu lernen. Das geht über Teach 폷 Teach Lesson. Man kann den Teacher auch auf automatisch stellen. Dazu aktiviert man allerdings zuerst das Error-Diagramm, damit man sieht, was der Lehrer für Erfolge oder Misserfolge erzielt (Teach 폷 Net Error Viewer). Nun startet man die Automatik: Teach 폷 Start Teacher (Auto). Es zeigt sich, dass sich die Fehlerrate irgendwie festklemmt. Das Ganze scheint nicht so recht zu funktionieren. Also halten wir an: Teach 폷 Stop Teacher (Auto). Überprüfen können wir, indem wir das Netzwerk in Betrieb nehmen: Net 폷 Start Thinking (Auto). Nun können wir eins der Eingabeneuronen auswählen und 0 oder 1 eintippen. Hinterher sollte an den Ausgangsneuronen die richtige Antwort »aufleuchten«. 000 funktioniert noch einwandfrei. Bei der Eins 001 gibt es schon Probleme. Das Netz meint, das könnte Eins und Drei sein. Zwei 010 wird für Zwei und Drei gehalten, nur bei 011, also der Drei, kommt auch die Drei, wobei das Ergebnis von der Lerndauer abhängt. Trotzdem ist es nie wirklich richtig. Woran kann das liegen? Was sich schon beim Perceptron zeigte: Durch die direkte Verbindung von Eingangs- mit Ausgangsneuronen sind die Möglichkeiten der Verschaltung relativ beschränkt. Es lässt sich mathematisch sehr schön zeigen, dass es sich um einen linearen Klassifikator handelt, worauf ich hier jedoch verzichte. Wenn man eine weitere Neuronenebene, die sogenannten Hidden Neurons (versteckte Neuronen) einführt, kommt man in den nichtlinearen Bereich und kann komplexere Unterscheidungen realisieren.

525

13.3

13

Denkmaschine

Bauen wir also ein Netzwerk aus 8 Neuronen, drei Eingangs-, drei Ausgangs- und zwei versteckten Neuronen. Die versteckten Neuronen sind vom Typ Hidden und haben eine LOGISTIC-Funktion. Schon nach relativ wenigen Lektionen haben sie »verstanden«, um was es geht. Das sieht man auch sehr gut am Fehlerdiagramm (siehe Abbildung 13.3). Schon nach 100 Trainingsläufen kann man überprüfen, ob das zu Erlernende verstanden wurde. Das sollte in der Tat der Fall sein. Also alle Zahlen sollten richtig interpretiert werden. Lediglich bei der Drei zeigt sich eine kleine Schwäche, indem die 0,5 nicht überschritten wird. Dadurch haben wir kein echtes binäres »Ja« an dieser Stelle. Trotzdem wird die Drei eindeutig stärker angesprochen als die beiden anderen Ausgangsneuronen. Das wird auch nicht viel besser, wenn man entsprechend länger trainiert (siehe Abbildung 13.2).

Abbildung 13.2

1, 2, 3 – Computerdenkerei

Natürlich sind das nicht die Leistungsgrenzen neuronaler Netze. Aber es zeigt sich schon, dass die Ergebnisse nicht unbedingt so eindeutig sind wie bei herkömmlicher Software. Deshalb können neuronale Netze auch nicht für alle Anwendungsfälle genutzt werden.

526


Abbildung 13.3

Lernkurve zum Erfolg

Praxis II: Das Märchennetz Das Märchennetz beruht auf folgender Geschichte: Um die Rotkäppchen-Katastrophe zu verhindern, die uns von den Gebrüdern Grimm überliefert ist, entschloss man sich, das kleine Mädchen genau zu instruieren. Man wies es darauf hin, dass es drei Lebewesen begegnen könne. Der Großmutter, die es an ihren großen Augen erkenne, ihrer runzligen Haut und der Freundlichkeit. Ihr solle es sich nähern, etwas zu essen anbieten und einen Kuss auf die Wange geben. Außerdem gäbe es im Wald noch einen freundlichen Holzfäller. Er hätte zwar große Ohren, sähe aber recht gut aus. Zu ihm sollte es ebenfalls gehen, ihm etwas aus dem Korb zu essen geben und ihn bitten, ihm gegen den Wolf zu helfen. Den Wolf aber, den würde es wie eh und je an den großen Augen, den großen Ohren und den großen Zähnen erkennen. Hier helfe bloß noch schreien, weglaufen und den Holzfäller zu suchen. Diese einfachen Zusammenhänge kann sich nicht nur Rotkäppchen merken. Ein einfaches Netz mit Eingabe- und Ausgabeneuronen, ohne Zwischenschicht, kann sich das bereits merken. Wird jedoch ein dreischichtiges Netz mit drei verdeckten Neuronen verwendet, so repräsentieren diese Neuronen nach dem Lernen – so unglaublich es klingt – jeweils eine Figur aus dem Märchen. Wohlgemerkt, ohne dafür bestimmt gewesen zu sein. Das gelingt auch mit vier verdeckten Neuronen. Werden die entsprechenden Eigenschaften im Inputvektor aktiviert, übernimmt stets das dafür auserwählte verdeckte Neuron die Hauptübertragungsleistung zum Output. Offenbar abstrahiert bereits dieses einfache Netz, dass hier drei Objekte

527

13.3

13

Denkmaschine

beteiligt sind. Ein Hinweis darauf, wie Neuronen sich ihre Welt durch Abstraktion selbst erschaffen? Das sollten wir natürlich ausprobieren. Wir haben also sechs Eingangs- und sieben Ausgangsneuronen und folgenden Sachverhalt: Großmutter Input: 1 2 große Augen 3 4 Freundlichkeit 5 runzlige Haut 6 Output: 10 11 12 13 Kuss auf die Wange geben 14 nähern 15 Essbares anbieten 16 Holzfäller Input: 1 große Ohren 2 3 4 Freundlichkeit 5 6 sieht gut aus Output: 10 11 12 13

528


14 nähern 15 Essbares anbieten 16 um Hilfe bitten Wolf Input: 1 große Ohren 2 große Augen 3 große Zähne 4 5 6 Output: 10 weglaufen 11 schreien 12 Holzfäller suchen 13 14 15 16 Das trainierte Netz finden Sie auf der DVD unter Software zum Buch\Kap13\ NNs\memBrain\Rotkäppchennetz.mbn. Nachdem Sie es geladen haben, klicken Sie auf Net 폷 Start Thinking (Auto). Geben Sie jetzt die Inputwerte entsprechend dem Märchen ein. Beim Wolf wird das Neuron 9 am aktivsten sein (siehe Abbildung 13.4), bei der Großmutter das Neuron 8 und beim Holzfäller das Neuron 7. Das ist doch ein ganz erstaunliches Ergebnis. Es hat auch nichts damit zu tun, dass sich aktive Neuronen gegenüberliegen. Je nachdem, wie sich das Netz einstellt, kann es auch sein, dass das Neuron 9 die Großmutter wird und 8 der Wolf. Das ist völlig unabhängig von der sogenannten Netztopologie, dem geometrischen Aufbau des Netzes. Auf der DVD finden Sie weitere Simulatoren für neuronale Netze, unter anderem auch sinn2.1 und RecallEvaluation, ein sehr professionelles, aber für Tests eingeschränktes Programm. Es bietet dem geneigten Leser jedoch die Möglichkeit, noch wesentlich tiefer in diese Materie einzusteigen.

529

13.3

13

Denkmaschine

Abbildung 13.4

Das Neuron 9 ist der böse, böse Wolf.

»Wir haben ein neuronales Netz entwickelt, das die Leistung eines KatzenKortex übersteigt.« – Quelle: IBM *** »Wer braucht schon einen Computer, der 22 Stunden am Tag schläft und sein Gewölle auf den Teppich kotzt?« – Anonymus

13.4

Zelluläre Automaten

Neuronale Netze sind zwar ein eigenständiges Forschungsgebiet innerhalb der Informatik, aus der Sicht der Mathematik sind sie jedoch nur ein Teilgebiet eines noch interessanteren Forschungsfeldes, nämlich der zellulären Automaten. Auch wenn Nervenzellen durch Abertausende von Fortsätzen miteinander verbunden sind, so stellt dies mathematisch gesehen nur Nachbarschaftsverhältnisse im Sinne eines zellulären Automaten dar. Eine Zelle verhält sich so, wie sie von den Nachbarzellen beeinflusst wird. Die Anzahl der Nachbarn hängt von der Dimensionalität des sogenannten Zellularraums ab. In einem eindimensionalen Zellularraum hat eine Zelle zwei Nachbarn, in einem zweidimensionalen Raum acht Nachbarn, in einem dreidimensionalen 26, in einem vierdimensionalen 80 usw. Unser Gehirn besitzt Nervenzellen, die in einem Zellularraum arbeiten, der über 400 Dimensionen besitzt.

530


Zwei Regeln zeigen die Verwandtschaft zwischen neuronalem Netz und zellulärem Automaten: 왘

Erste Regel: Jeder Zelle im Zellularraum ist ein Zustand zugeordnet.

왘

Zweite Regel: Die Änderung der Zustände erfolgt über Zustandsübergangsregeln.

Wenn wir uns nun einfache zelluläre Automaten ansehen, sollte uns bewusst sein, dass sie nichts anderes als primitive Modelle unseres Gehirn darstellen. Ihr Zusammenwirken zeigt aber auch, wie zukünftige Rechner mit immensen Prozessorzahlen und einer vollständigen Vernetzung zusammenarbeiten könnten und welche Effekte in solchen Systemen auftreten. Und vielleicht lüften sie eines Tages das Geheimnis künstlichen Denkens.

13.4.1 Geschichte Mit einem Paukenschlag, der zwar rein akademisch war, aber trotzdem große finanzielle Auswirkungen hatte, traten zelluläre Automaten 1970 an die Öffentlichkeit. Nachdem John H. Conways Idee vom Game of Life in der Kolumne »Mathematische Spielereien« der Scientific American erschien, verursachte sie durch unautorisierte Programmläufe mathematisch interessierter Programmierer und Wissenschaftler weltweit einen Riesenschaden durch massenhafte Vergeudung der damals noch kostbaren Prozessorzeit.

Abbildung 13.5

Conway entwickelte Life auf einem Go-Spielbrett.

»Obwohl auf einer nüchternen mathematischen Basis aufgebaut, zeigte sich doch mitten in der Zeit der Großrechner die Befähigung des Computers zum ›Spielzeug‹. Der entstandene Schaden zeigte zugleich die Verwundbarkeit der Computer-Infrastruktur und deutete bereits 10 Jahre vorher das Kommen der großen Problematik Computerviren an.«2 2 Quelle: http://www.pcwelt.de/start/sicherheit/virenticker/news/187451/erste_computer_virus_ wird_25_jahre/

531

13.4

Denkmaschine

Conways Life folgt ganz einfachen Regeln. In einer Welt, die einem Rechenblatt aus einem Schulheft entspricht, bleibt ein Rechenhäuschen mit Inhalt besetzt, wenn es zwei oder drei Nachbarn hat. Hat es mehr oder weniger Nachbarn, verschwindet es. Hat ein leeres Feld aber genau drei Nachbarn, wird es gefüllt. Dieses einfache Spiel, das ein Computer mit sich selbst spielen kann, kostete damals die Wirtschaft Abermillionen DM Großcomputer-Rechenzeit.

Quelle: www.nndb.com/people/680/000082434

13

Abbildung 13.6

John Horton Conway

Conway ist keineswegs der Erfinder des zellulären Automaten. Dessen eigentlichen Schöpfer sind Stanislaw Ulam und John von Neumann. Ursprung war eigenartigerweise die Idee, einen sich selbst reproduzierenden Automaten und gezieltes Wachstum zu simulieren. Beide arbeiteten damals am Manhattan-Projekt, als sie die Idee des zellulären Automaten entwickelten. Von Neumann ist uns als Schöpfer der Von-Neumann-Architektur bekannt. Seine damalige Entwicklung des Neumann-Automaten, eines zellulären Automaten, der in der Lage ist, sich beliebig oft selbst zu reproduzieren, zeigt deutlich, wie wenig damals die Architektur des heutigen Computers schon eindeutig festgelegt war. Es gibt heute längst Prozessorchips, deren Architektur auf zellulären Automaten beruht3. Ulam gilt als der eigentliche Vater der Wasserstoffbombe (neben Edward Teller), von Neumann arbeitete ebenfalls als Mathematiker an ihrer Entwicklung mit. Er 3 Siehe http://personalpages.manchester.ac.uk/staff/p.dudek/scamp2/

532


galt als eiskalter Technokrat, in dessen Kopf Schöpfung und totale Zerstörung sehr dicht beieinander lagen.

13.4.2 Zellenspiele Um Conways Spiel einmal in Aktion zu sehen und zu verstehen, worum es überhaupt geht, starten wir ein ganz einfaches Programm für zelluläre Automaten. Es heißt Minimal.jar und liegt auf der DVD unter Software zum Buch\Kap13\MinimalLife\. Gestartet wird es mit java -jar Minimal.jar

Es öffnet sich ein Dialog mit Rechenfeldern, über die ein Zufallsgenerator gefüllte Zellen verteilt hat. Die Berechnung beginnt sofort. Falls der Dialog etwas zu klein ist, kann man ihn mit der Maus wie üblich auseinanderziehen.

Abbildung 13.7

Minimalversion von Game of Life

Wenn man das Spiel zum ersten Mal sieht, kann man vielleicht noch am ehesten nachvollziehen, welche Faszination es damals ausgeübt haben muss. Conway hat es selbst mit Hilfe eines Go-Spielbretts entwickelt (siehe Abbildung 13.5), und das »Gezappele«, das entsteht, wenn ein Rechner die Regeln durcharbeitet, selbst auch nicht gesehen, bis man es ihm zeigen konnte. Es scheint völlig unerklärlich, wie symmetrische Figuren von selbst entstehen. Manche Figuren machen sich sogar auf den Weg, ihre zweidimensionale Welt zu erkunden. Sie »zerbrechen« jedoch, sobald sie mit irgendetwas anderem zusammenstoßen.

533

13.4

13

Denkmaschine

Man denkt erst einmal, um so etwas zu realisieren, muss ein kompliziertes Programm nötig sein. Genau das Gegenteil ist der Fall. Wen es interessiert, der kann sich den Kern des Programms im folgenden Praxisteil anschauen. Praxis: Conways Life – die Minimalversion Wie Conways Life funktioniert, sei hier an etwas Java-Code gezeigt. Es dürfte selbst für Laien halbwegs verständlich sein. Grundlage des Ganzen ist ein Array, also ein Zahlenfeld. Man schreibt es feld[x][y], wobei in den Klammern die Nummer des Feldes als Zeilen- und Spaltenzahl steht. Kern einer Softwarelösung des Conway-Automaten ist eine einfache If-Abfrage: if (anzahl == 3) newPointField[i][j] = LIFE; if (anzahl == 2 && pointField[i][j] == LIFE) newPointField[i][j] = LIFE;

Gibt es drei Nachbarzellen, entsteht oder überlebt eine Zelle. Gibt es bei einer lebenden Zelle zwei Nachbarzellen, überlebt sie. Die Abfrage lässt sich noch weiter verdichten: if ((anzahl == 3) || (anzahl == 2 && pointField[i][j] == LIFE)) newPointField[i][j] = LIFE;

Vor der Abfrage auf die Nachbarschaft wird die Anzahl anzahl mit einer Additionsfunktion der Nachbarschaftszellen ermittelt. anzahl = pointField[i - 1][j - 1] + pointField[i][j - 1] + pointField[i + 1][j - 1] + pointField[i - 1][j] + pointField[i + 1][j] + pointField[i - 1][j + 1] + pointField[i][j + 1] + pointField[i + 1][j + 1];

Das Ganze wird in einer Schleife über alle Felder des zellulären Automaten ausgeführt. Das ist alles! Man braucht sich wirklich nicht hinzusetzen, um einen zellulären Automaten zu programmieren. Es gibt reichlich Programme dafür im Internet. Selbst Programme, die dreidimensionale zelluläre Automaten in erträglicher Laufzeit auf dem PC simulieren, sind dort zu finden. Zu empfehlen ist die Software Golly, die es für die Systeme Linux, Mac und Windows gibt. Sie finden sie im Internet unter http://golly.sourceforge.net. Zwei Versionen gibt es auch auf der DVD: Software zum Buch\Kap13\Golly\, dort z. B. golly-2.1-win.zip.

534


Golly bietet zahlreiche Beispiele zellulärer Automaten verschiedenster Bauart – so z. B. die ersten Automaten und die, die sich selbst replizieren mit der VonNeumann-Regel, und natürlich zahlreiche Versionen von Conways Game of Life. Die Installation bereitet keinerlei Probleme, weil Golly ohne zusätzliche DLLs auskommt und lediglich das Verzeichnis aus der gepackten Datei auf die Platte kopiert werden muss. Außerdem ist der Quellcode verfügbar, falls man die Programmierung studieren oder die Software selbst kompilieren möchte. Gestartet wird durch einen Doppelklick auf die Datei Golly.exe.

Abbildung 13.8

Golly mit Game of Life

Die Software wird durch das sogenannte Life-Lexikon von Stephen Silver ergänzt, das in erster Linie eine Sammlung der bekanntesten Muster des Game of Life darstellt. Beides, das Programm und die Dokumentation, sind geradezu gigantisch und bieten Interessantes für mehrere Wochen. Nach der Installation und dem Start des Programms haben wir einen nicht unüblichen Dialog mit Menüs, Icon-Funktionsleiste und einem Verzeichnisbaum links. Das Dominante ist natürlich das Rechenblatt in seiner dunkleren Farbe. Beginnen wir damit, dass wir Conways Figur vom Go-Brett realisieren (siehe Abbildung 13.5). Wir dürfen dabei nur die weißen Steine in das Feld übertragen.

535

13.4

13

Denkmaschine

Sobald wir die Maus über das Simulationsfeld bewegen, verwandelt sie sich in einen Stift. Durch einfaches Klicken mit der linken Maustaste setzen wir das Feld. Klicken wir erneut darauf, wird es wieder entleert. Wenn wir die Figur, die man übrigens als Gleiter bezeichnet, erstellt haben, können wir sie durchrechnen lassen, indem wir die (ÿ_)-Taste drücken. Jedes Tab berechnet eine sogenannte Generation, also alle Felder und ihre Beziehung zueinander, einmal durch. Wichtig ist dabei, dass Felder, die sterben, noch für ihre Nachbarn gelten, Felder, die neu entstehen, aber noch nicht. Das erklärt auch die schwarzen Steine in der Abbildung: Es sind Felder, die neu belegt werden. Die (ÿ_)-Taste bewirkt den Einzelschrittmodus. Es gibt natürlich auch einen Run-Button. Er liegt oben links als »Start generating«. Allerdings läuft das Programm mit einem schnellen Rechner so rasch, dass man die Vorgänge kaum verfolgen kann. Deshalb ist es vor allem sinnvoll, mit Control 폷 Auto Fit die Verfolgung einzuschalten. Gleiter sind vor allen Dingen für die Konstruktionen interessant, die selbst Rechenvorgänge simulieren, sie fungieren hier als Impuls oder als Bit.

Abbildung 13.9

Vier Gleiter auf Kollisionskurs

Dabei kollidieren Gleiter mit anderen Gleitern oder treffen auf eine Struktur, die sich durch ihren Aufschlag bleibend verändern. Eine einfache Gleiterkollision zeigt Abbildung 13.9.

536


Gleiter (engl. Glider) Ein Gleiter ist ein Muster in einem zellulären Automaten, das sich in der Abfolge der Generationen selbständig durch den Zellraum bewegt. Ein Gleiter kann sich rechtwinklig zu den Zellen, aber auch diagonal dazu bewegen. Größere werden oft als Schiffe, Segler oder Raumschiffe bezeichnet. Gleiter ist jedoch die ursprüngliche Bezeichnung. Gleiterkanonen Gleiterkanonen sind Muster, die Gleiter erzeugen. Es gibt Kanonen, die nur einen Gleiter absondern, aber auch Gleiterkanonen, die zyklisch immer wieder Gleiter absetzen. Mit einer Gleiterkanone wurde bewiesen, dass GoL zu grenzenlosem Wachstum befähigt ist. Das Gegenstück zu einer Gleiterkanone ist ein Gleiterfresser. Er eliminiert anfliegende Gleiter, ohne selbst Schaden zu nehmen. Diese Beispiele sind einfache Gleiter, theoretisch sind Gleiter beliebiger Größe denkbar. Ein entsprechendes Beispiel finden wir in Golly als Spaceships\spaceship-types.rle. Glider dieser Größe bezeichnet man üblicherweise als Raumschiffe (Spaceships). Es gibt noch Lokomotiven, die eine Art Dampfwolke aus den hellen Kästchen hinter sich herziehen. Man findet dazu Beispiele unter Spaceships\ Smallest-low-period.rle. Überhaupt befassen sich alle Dateien unter Spaceships mit Glidern. Unter ihnen gibt es solche, die sich diagonal durch das Feld bewegen, wie der erste Glider, den wir selbst realisiert haben, und solche, die sich orthogonal, also parallel zu den Feldrändern bewegen.

13.4.3 Muster Zelluläre Automaten sind, wenn man so will, grafische Computer. Sie arbeiten mit Bildpunkten und lassen auf diese Weise mathematische Zusammenhänge direkt sichtbar werden. Wenn man Bildpunkte gruppiert, entstehen Muster. Da immer wieder gleiche, aber auch ähnliche Muster auftreten können, hat man diesen Mustern Namen gegeben. Man hat sogar Muster gefunden, die bei unterschiedlichen Automaten auf die gleiche Weise auftreten und sich auch gleich verhalten. Die Muster lassen sich nach folgenden Kriterien in Gruppen aufteilen: 왘

konstante Muster: Muster, die unverändert erhalten bleiben

왘

wiederkehrende Muster: Muster, die sich periodisch wiederholen (Oszillator)

왘

laufende Muster: Muster, die sich fortbewegen (Glider)

왘

chaotische Muster: Muster, die unregelmäßige Formen annehmen 537

13.4

13

Denkmaschine

Conway entdeckte bereits eine ganze Reihe von Mustern und gab ihnen Namen, wie wir aus dem Artikel von Martin Gardner erfahren können. Er orientierte sich bei den Namen an der Anzahl der Zellen, die zu einem Muster gehören, z. B. Pentomino, Pentadecathlon u.Ä. Das Pentadecathlon wurde bereits 1970 von Conway beschrieben. Es ist ein oszillierendes Muster. Von Stephen Silver wurde ein Lexikon der Life-Muster erstellt. Man findet es im Programm Golly und im Internet auf der Homepage http://www.argentum.freeserve.co.uk/lex_home.htm. Life-Hobbyisten, die gezielt nach neuen Mustern suchen, verwenden dazu spezielle Software, die Muster nach bestimmten Regeln aufbauen oder in zufälligen Mustern nach Regelmäßigkeiten suchen. Trotz der Einfachheit zellulärer Systeme gibt es einige Sachverhalte, die bezüglich des Systemverhaltens eine große Rolle spielen. Diese sollen nach dem folgenden Praxisteil betrachtet werden. Praxis: Muster aus dem Game-of-Life-Automaten Die Anzahl möglicher Muster ist sicher unbegrenzt. Hier einige interessante Muster aus dem Game-of-Life-Automaten:

Abbildung 13.10

538

Gleiter (Glider)


Bewegt sich diagonal durch den Zellraum:

Abbildung 13.11

Ein »Z«

Nach zwölf Generationen haben sich aus dem »Z« zwei Gleiter entwickelt:

Abbildung 13.12

Fontäne (fumarole)

539

13.4

13

Denkmaschine

Nur der obere Teil ist dynamisch:

Abbildung 13.13

Pentadecathlon

Die Lichtgeschwindigkeit Muster, die sich bewegen, haben auch eine bestimmte Geschwindigkeit. Ein Muster, das sich in einer Generation genau ein Feld weiterbewegt, hat die Geschwindigkeit c, die man als Lichtgeschwindigkeit bezeichnet, weil sie nicht überschritten werden kann. Die schnellsten heute für GoL bekannten Gleiter haben c/2, brauchen also zwei Generationen, um ein Feld zurückzulegen (siehe Abbildung 13.14).

Abbildung 13.14

540

Leichtes Raumschiff (Lightweight Spaceship) mit c/2


Abbildung 13.15

Spider mit c/5

13.4.4 Zellraum Zelluläre Automaten beziehen ihre Anschaulichkeit in erster Linie aus der Möglichkeit ihrer grafischen Darstellung. Im alltäglichen Leben verwenden sie in erster Linie Flächen (z. B. Papier) zur grafischen Darstellung, so war es sinnvoll, solche Automaten auf Flächen zu entwickeln. Diese Flächen bezeichnen wir als Zellraum oder Raum des Automaten. Ein zellulärer Automat befindet sich ganz innerhalb seines Raumes, er unterliegt keinerlei Einfluss von außerhalb. Demnach können wir hier auch nicht von einer Blackbox sprechen, sondern von einem Universum, also von etwas, was kein Außerhalb kennt. Der Raum eines Automaten dient auch zu seiner Klassifizierung. So sprechen wir z. B. von ein-, zwei- oder dreidimensionalen Automaten. Erstreckt sich ein Automat nur über eine Linie, sprechen wir von einem eindimensionalen Automaten. Am häufigsten sind zweidimensionale Automaten. Sie müssen sich nicht über eine Ebene erstrecken. Ihr Raum kann auch als Fläche um einen Körper gewickelt sein. So können wir uns z. B. Kugeloberflächen oder Oberflächen von Ringen als zelluläre Automaten vorstellen. Sie wären in einem solchen Fall endlich, aber unbegrenzt. Dimensionierung der Zellräume: 왘

eindimensionaler Zellraum Bereits 1970 bewies A. R. Smith, dass jede Turingmaschine durch einen eindimensionalen zellulären Automaten simuliert werden kann.

왘

zweidimensionaler Zellraum üblicher Zellraum für zelluläre Automaten (z. B. GoL)

왘

dreidimensionaler Zellraum Beispiel: Erweiterung von GoL auf drei Dimensionen (siehe Abbildung 13.16)

541

13.4

13

Denkmaschine

왘

mehrdimensionaler Zellraum Nur rein mathematisch erforschbar, weil in unserer Welt nicht mehr darzustellen. Ein Gehirn oder das Universum lässt sich auf einen mehrdimensionalen zellulären Automaten abstrahieren.

Abbildung 13.16

3D-Gleiter im 3D-Zellraum

Raumgrenzen Ein spezielles Problem beim zellulären Automaten ist das Verhalten an den Rändern des Zellraumes. Trotz der gewaltigen Leistungsfähigkeit heutiger Rechner ist es unmöglich, einen zellulären Automaten mit einem unendlich großen Zellraum zu simulieren. Daher besitzt jeder Zellraum irgendwo Grenzen. Bei Golly liegen sie weit draußen. Je nach Dimension und Art können die Grenzen unterschiedlich aussehen. Man kann prinzipiell drei Lösungen unterscheiden: 왘

Begrenzt Ist der Zellraum begrenzt, muss der Programmierer festlegen, wie sich Muster verhalten, die die Grenze berühren oder überschreiten. Es bieten sich dabei zwei Möglichkeiten an: Entweder geht man davon aus, dass alle Felder außerhalb des Universums belegt sind (siehe Abbildung 13.17), oder davon, dass sie unbelegt sind (siehe Abbildung 13.18).

542


Abbildung 13.17

Das Nichts ist belegt.

Abbildung 13.18

Das Nichts ist unbelegt.

왘

Endlich, aber unbegrenzt Dieses Verhalten erreicht man dadurch, dass man den Zellraum so krümmt, dass sich die Enden berühren. Muster, die an einem Ende den Zellraum verlassen, treten am entgegengesetzten Ende wieder ein.

Verschiedene Körper bieten sich an, wobei eine Kugel weniger geeignet ist, weil die Zahl der Zellen zu den Polen hin abnimmt. Neben einem Kubus, bei dem die Muster um die Kanten wandern, eignet sich ein Kissen oder ein Torus (siehe Abbildung 13.19) ganz gut. Die Oberflächen werden im Programm als ebene Fläche dargestellt, Muster überspringen dabei die Nahtstelle (siehe Abbildung 13.20).

543

13.4

13

Denkmaschine

Abbildung 13.19

Torus-Oberfläche als Zellraum

Abbildung 13.20

Gleiter auf der Torus-Oberfläche aus Abbildung 13.19

왘

Scheinbar unendlich Wenn man nur die Felder durchrechnet, die auch wirklich gefüllt sind, kann man gewaltige Räume durchrechnen. Vermehren sich die Zellen allerdings exponentiell, so gelangt man irgendwann an den Punkt, an dem der Hauptspeicher voll ist; hier wäre ein gekrümmter Raum nicht schlecht. Aber solche Hochleistungssimulationen bleiben meist stecken oder stürzen ab.

Zellen Zellen sind die grundlegenden Bestandteile des zellulären Automaten, sozusagen die Atome. Je nach der Dimension des Zellraumes handelt es sich um Punkte, Teilflächen, Würfel o. Ä.

544


Bereits die Griechen erkannten die Bedeutung des Vorhandenseins von Atomen, den grundlegenden Bausteinen der Welt. Sie führten insbesondere die Eigenschaften der Stoffe und Gegenstände auf das Verhalten der Atome zurück. Somit sahen sie bereits die Welt als zellulären Automaten an, sogar viel mehr, als wir dies heute tun, obwohl wir uns inzwischen die Automatentheorie erdacht haben. Zellen sind im zellulären Automaten das sichtbare Pendant der Regeln. Bei manchen Versionen zeigen sie ihren Zustand durch unterschiedliche Farben an. Beim Game of Life können die Zellen lediglich zwei Zustände annehmen, was durch gefärbt und ungefärbt dargestellt wird. Übergangsfunktion/Regel Die Übergangsfunktion des Game of Life lautet: »Stellen Sie sich eine in einem rechteckigen Gitternetz lebende Population vor. Jedes Quadrat in dem Netz enthält ein Mitglied dieser Population oder ist leer. Jedes Quadrat hat acht angrenzende Quadrate, die unter Umständen einen sogenannten ’Nachbarn’ enthalten. Die Population entwickelt sich von Generation n zu Gerneration n+1 nach folgenden Regeln fort: Wenn ein Quadrat in der Generation n ein Mitglied enthält, enthält es auch in der Generation n+1 ein Mitglied, wenn es in Generation n zwei oder drei Nachbarn hatte; sonst ist es leer. Wenn ein Quadrat in der Generation n leer ist, enthält es in der Generation n+1 ein Mitglied, wenn es in der Generation n genau drei Nachbarn hatte, sonst bleibt es leer.« – Aus: Richard Conway: Der neue Programmierstil – gezeigt an PL/1. Hanser 1981 In den Regeln (der Übergangsfunktion) ist festgelegt, wie ein Zustandsübergang der Zellen zustande kommt. Die Regeln werden meist global und in Generationswechseln eingesetzt, was bedeutet, für alle Zellen gleich und auch zur gleichen Zeit. Nach der einmaligen Ausführung der Regeln für alle Zellen erreicht man die Generation t+1. Regeln berücksichtigen häufig die Anzahl der Nachbarzellen und ihre Zustände. Wobei man die verschiedensten Nachbarschaften berücksichtigen kann. Es kann aber auch der eigene Zustand der Zelle berücksichtigt werden (meist bei künstlichen neuronalen Netzen). In den Regeln kann auch ein Schwellwert festgelegt sein, bei dessen Überschreiten das Verhalten umkippt. Wir können sagen: Alle Zellen mit einer Anzahl 545

13.4

13

Denkmaschine

Nachbarn, die Drei übersteigt, bleiben oder werden neu gefüllt. Solche zellulären Automaten haben große Ähnlichkeiten mit künstlichen, neuronalen Netzen. Für die Regeln haben sich feste Schreibweisen eingebürgert. Man gibt die Anzahl(en) der Nachbarzellen an, bei der eine Zelle überlebt, und die Anzahl(en), bei der eine Zelle geboren wird, getrennt durch den Schrägstrich. Die Anzahl für sterbende Zellen ergibt sich von selbst. 345/45 bedeutet also: Bei 3, 4 und 5 Nachbarzellen bleibt die aktuelle Zelle, und bei 4 sowie bei 5 Nachbarzellen wird eine neue Zelle geboren. Bei den übrigen Anzahlen stirbt die Zelle.

In dieser Schreibweise wird Conways GoL (Game of Life) durch folgenden Term dargestellt: 23/3 Es gibt weitere interessante Regeln im Zusammenhang mit Conways GoL, das Gleiche gilt auch für andere zelluläre Automaten, wie beispielsweise den Replikationsautomaten nach von Neumann. Im Folgenden betrachten wir einige Regeln und ihre Welten. Sie gelten für Moore-Nachbarschaften. 왘

Einfache oszillierende Welt: 2/3 Einfache oszillierende Muster entstehen nach kurzer Zeit.

왘

Kegelwelt: 3/3 Welt endet mit einfachen oszillierenden Mustern, wobei das sogenannte Kegel-Muster häufig vorkommt.

왘

Kopierwelt: 1357/1357 Einfache Muster werden ständig kopiert.

왘

Labyrinthwelt: 2345/3 Labyrinthartige und symmetrische Muster werden gebildet (siehe Abbildung 13.21).

Es gibt weitere Welten, die oft auch Ähnlichkeiten im Verhalten der Muster zeigen. Die einzelnen Regeln lassen sich mit dem Programm LifeMaster gut erforschen. Sie finden es auf der Buch-DVD unter Software zum Buch\Kap13\LifeMaster\ Life003.jar.

546


Abbildung 13.21

»Netzforschung« mit LifeMaster (Labyrinthwelt 2345/3)

Nachbarschaften Die Nachbarn einer Zelle sind Zellen, die in irgendeiner räumlichen Beziehung zur Zelle stehen. Bei zellulären Automaten kennen wir zwei Nachbarschaften: 왘

Moore-Nachbarschaft

왘

Von-Neumann-Nachbarschaft

Abbildung 13.22

Nachbarn

547

13.4

13

Denkmaschine

Moore-Nachbarschaft Als Moore-Nachbar gilt die Nachbarzelle, die wenigstens eine Seite und oder eine Ecke mit einer Zelle gemeinsam hat. Sie hat ihren Namen von dem amerikanischen Mathematiker Edward F. Moore (1925–2003) und wird auch als 8er-Nachbarschaft bezeichnet.

Abbildung 13.23

Moore-Nachbarschaft

Von-Neumann-Nachbarschaft Bei der Von-Neumann-Nachbarschaft gelten nur die Zellen als Nachbarn, die eine Kante mit der Zelle gemeinsam haben.

Abbildung 13.24

Von-Neumann-Nachbarschaft

Es können beliebige Nachbarschaften definiert werden. Auch mit weit entfernten Zellen können Nachbarschaften festgelegt werden. Eine weitere Möglichkeit ist die Wichtung der Nachbarschaften entsprechend ihrer Entfernung von der Zelle. Folgende Abbildung zeigt eine Moore-Nachbarschaft, in der die direkten Nachbarn der Nachbarn ebenfalls berücksichtigt werden.

Abbildung 13.25

548

Erweiterte Moore-Nachbarschaft


Rückkopplung Natürlich stellt sich die Frage, warum zelluläre Automaten so funktionieren, wie sie funktionieren. Warum erinnern sie uns an das Verhalten von Lebewesen oder physikalische Effekte aus der unbelebten Natur? Eine Antwort darauf heißt: Rückkopplung. Die Existenz einer Zelle hängt von den Zellen ihrer Umgebung ab. Ihre Existenz aber beeinflusst wiederum die Zellen in ihrer Umgebung. In der Umgangssprache und in der Technik nennen wir diese Wirkung Rückkopplung. Der Rückkopplung sehr ähnliche Effekte zeigen die aus der Physik sehr bekannten Wechselwirkungen. Dort unterscheidet der Fachmann die starke Wechselwirkung, die elektromagnetische Wechselwirkung, die schwache Wechselwirkung und die Gravitation – Effekte, die sich mit rückgekoppelten Systemen simulieren lassen. Aber auch in der lebenden Natur, in der Ökologie genau wie in der Ökonomie sind Wechselwirkungen/Rückkopplungen gang und gäbe. Aus diesem Grund sind zelluläre Automaten ideal dafür geeignet, solche Vorgänge zu visualisieren. Vereinfacht ausgedrückt sind es grafische Darstellungen von Rückkopplungsvorgängen. Selbst die Vorgänge im menschlichen Gehirn kann man mit zellulären Automaten abbilden. Die Aktivitäten der Neuronen beeinflussen sich gegenseitig und hängen direkt von den Aktivitäten der »benachbarten« (verbundenen) Neuronen ab.

13.4.5 Metaautomaten Die Möglichkeit, Metaautomaten zu bilden, ist die interessanteste Eigenschaft der zellulären Automaten. Sie besagt nämlich nicht mehr und nicht weniger, als dass man mit diesen Simulationen Turingmaschinen abbilden kann. Einfach gesagt, mit zellulären Automaten kann man Computer bauen oder auch wieder zelluläre Automaten, also eben alles das, was auch ein Computer kann. Wireworld ist ein zellulärer Automat, mit dem das einfacher geht als mit Life. »Der Computer ist ein elektronisches Wunderwerk, das in einer zehntausendstel Sekunde die verwickeltsten Rechen- und Buchungsoperationen durchführt – und dann die Kontoauszüge mit zehn Tagen Verspätung schickt.« – Anonymus

549

13.4

13

Denkmaschine

13.4.6 Wireworld Als Wireworld wird ein zellulärer Automat bezeichnet, den Brian Silverman im Jahre 1987 in seinem Simulationsprogramm »Phantom Fish Tank« verwendet hat. Richtig bekannt wurde Wireworld anschließend mit einem Artikel in der Kolumne »Computer Recreations« des Magazins »Scientific American«. Die Wireworld-Zellen kennen vier Zustände: 1. leere Zelle – ist funktionslos 2. aktive Zelle – elektrischer Leiter 3. Stromkopf – Signalbeginn 4. Stromende – Signalende Diese Welt aus Draht arbeitet dabei nach folgenden Regeln: 1. Aus einem Stromkopf wird immer ein Stromende. 2. Aus einem Stromende wird ein elektrischer Leiter. 3. Aus einem Leiter wird ein Stromkopf, wenn genau ein oder zwei der benachbarten Zellen ebenfalls Stromköpfe sind. Im Grunde genommen simuliert Wireworld damit fließende Elektrizität, und mit den einfachen Regeln dieses zellulären Automaten kann der Strom sogar gesteuert werden. Entscheidend für die Steuerung ist allein die Anordnung der aktiven Zellen, des Leiters also. Auch diese Welt lässt sich relativ einfach in einer modernen Programmiersprache realisieren. Die Zustände der Zellen symbolisiert man mit verschiedenen Farben, beispielsweise so: colorZelle[LEER] = Color.WHITE; colorZelle[LEITER] = Color.BLACK; colorZelle[STROMKOPF] = Color.YELLOW; colorZelle[STROMENDE] = Color.BLUE;

Man durchläuft nun alle Zellen von Wireworld und prüft die Zellzustände, um sie den Regeln entsprechend anzupassen. if (zelle == STROMKOPF) tmpWelt[i][j] = STROMENDE else if (zelle == STROMENDE) tmpWelt[i][j] = LEITER else if (zelle == LEITER) { int nachbarschaft = pruefeNachbarschaft(i, j);

550


if (nachbarschaft == 1 || nachbarschaft == 2) tmpWelt[i][j] = STROMKOPF; else tmpWelt[i][j] = LEITER;

So einfach ist der Kern eines Wireworld-Programms aufgebaut. Golly ist in der Lage, auch Wireworld-Regeln zu realisieren. Mit ihm lassen sich WireworldAutomaten beliebiger Komplexität zeichnerisch aufbauen. Das kann bei ganz einfachen Leitungen anfangen, die bereits erstaunliche Eigenschaften haben, beispielsweise wie diese Timer (siehe Abbildung 13.26).

Abbildung 13.26

Verschiedene Timer

Bevor wir eine Wireworld-Schaltung aufbauen können, müssen wir erst die Wireworld-Regel aktivieren: Control 폷 Set Rule... Wählen Sie anschließend in der Combobox Wireworld aus, und bestätigen Sie mit OK. Mit dem Icon Show/hide all states lassen sich die möglichen Stati anzeigen. Einfache Leitungen werden mit der 3 gekennzeichnet, die blaue 1 steht für einen Stromimpuls. Wenn wir eine gerade braune Leitung haben und einen blauen Impuls mitten hineinsetzen, so läuft er, sobald wir die Berechnungen ausführen lassen, nach beiden Seiten davon. Um das zu verhindern, können wir mit

551

13.4

13

Denkmaschine

dem weißen Stein die Richtung vorgeben, indem wir ihn hinter den blauen Stein setzen. Diese Regeln reichen aus, um die verschiedenen Timer aus der Abbildung 13.26 zu realisieren. Eine Lösung gibt es auch auf der DVD unter Software zum Buch\ Kap13\Wireworld\Timer01.rle. Geladen wird sie einfach über File 폷 Open Pattern... Die Funktion sieht man am besten, wenn man mit der (ÿ_)-Taste schrittweise vorgeht. Einfach laufen lassen ist viel zu schnell. Man kann damit schon eine Menge anfangen. So lassen sich die Grundschaltungen für Computer damit aufbauen. Die Beispiele unter Other-Rules\Wireworld\flip-flop.mcl oder gate-Or.mcl zeigen es überdeutlich. Doch es geht noch weit mehr: zum Beispiel ein Rechner, der die Primzahlen ausrechnet. Das ist der sogenannte Wireworld-Computer, der von David Moore und Mark Owen in den Jahren 1992 bis 2004 entworfen wurde (siehe Abbildung 13.27) und der sich unter den Beispielen befindet (Other-Rules 폷 WireWorld 폷 primes.mc).

Abbildung 13.27

Ausschnitt aus dem Wireworld-Rechner (die Primzahl 61)

Diesen Rechner kann man natürlich nicht mit der (ÿ_)-Taste laufen lassen. Da braucht man schon folgende Optionen: Control 폷 Start Generating. 552


Trotzdem dauert es fünf Minuten, bis sich etwas tut. Wem das zu lange dauert, der kann die sogenannte Hyperspeed einschalten (Control 폷 Hyperspeed). Dann muss man allerdings aufpassen, dass man den Wechsel von der 3 zur 5 und zur 7 nicht verpasst.

13.4.7 Anwendung und Praxis Grundlage der Anwendung zellulärer Automaten in der Praxis ist die Definition des Automaten. Für den jeweiligen Anwendungsfall werden jeweils an das Problem angepasste Regeln und Automatenformen eingesetzt. Zelluläre Automaten sind mathematische Modelle zur Beschreibung eines komplexen Interaktionsgeschehnisses: Mit ihrer Hilfe kann man für komplexe Systeme die Wechselwirkungen beliebig vieler Teilkomponenten, die alle genau den gleichen Regeln folgen und sich nur in ihrer unmittelbaren Nachbarschaft ihres Lebensraumes mit den anderen Komponenten austauschen können, beschreiben.4 In der Praxis ist das Wissen um zelluläre Automaten aktueller denn je. Zahlreiche Hardwarelösungen im Bereich Visualisierung und Parallelisierung arbeiten bereits mit dem Modell des zellulären Automaten. Es gibt in der Tat Firmen, die zelluläre Automaten in »Silizium ätzen«, so dass man in einem gut ausgestatteten Hardwarelabor Experimente mit Prozessorgattern auf Basis von zellulären Automaten machen kann. Das ist insbesondere auf dem Gebiet der Bildverarbeitung möglich.5 So kann beispielsweise der SCAMP-3-Chip Conways Game of Life2 direkt mit seinem SIMD-Prozessor-Array ausführen.6 Konkrete Anwendungen sind: 왘

Simulation von Schwärmen/Schwarmverhalten

왘

Bildanalyse

왘

Untersuchung von Flächennutzungsplänen

왘

Simulation von Waldbränden

왘

Untersuchung geothermischer Prozesse (Vulkanausbrüche)

왘

Vorhersagen von Lawinen

4 http://www.tu-ilmenau.de/fakmn/fileadmin/template/ifp/physiksommer/2004/Zellulaere_ Automaten.ppt 5 http://personalpages.manchester.ac.uk/staff/p.dudek/scamp/ 6 http://personalpages.manchester.ac.uk/staff/p.dudek/scamp2/

553

13.4

13

Denkmaschine

왘

Modelle für Verkehrsstaus

왘

Simulation von Gasteilchen

왘

Darstellung chemischer Oszillationen

왘

Räuber-Beute-Modell

왘

Simulation von elektronischen Schaltungen mit Wireworld

Ein großes Problem der heutigen Informatik ist die Tatsache, dass Software trotz KI und genetischer Algorithmen keine wirklich universelle Plastizität, ähnlich der Neuroplastizität unseres Gehirns, besitzt. Als Entdecker der synaptischen Plastizität gilt der Psychologe Donald Olding Hebb. Bereits 1949 formulierte er die Hebbsche Lernregel in seinem Buch »The Organization of Behavior«. Auch wenn es eigentlich die neuronalen Netze sind, die auf Hebbs Regeln aufbauen, so kann man zellulären Automaten nicht jede Plastizität absprechen. Dadurch, dass eine Zelle ihre Nachbarschaft berücksichtigt, entsteht ein Gebilde, das sich »Umwelteinflüssen« anpassen und das Wachsen kann. So ist es nicht verwunderlich, dass man zelluläre Automaten in einem Atemzug mit Neuro- und Quantencomputern nennt.7 »Das Geheimnis des Erfolges der naturwissenschaftlichen Forschung liegt darin, die Komplexität des Ganzen durch den Blick auf seine Einzelteile zu reduzieren.« – Martin Gerhardt, Heike Schuster

13.4.8 Also sprach Aristoteles Zelluläre Automaten besitzen interessante Eigenschaften. Obwohl sie so erstaunlich sind, werden sie oft einfach akzeptiert und überhaupt nicht hinterfragt. Es gilt jedoch, alles zu hinterfragen, auch wenn es noch so unerklärbar scheint. Die Suche nach der Erklärung der zellulären Automaten führt uns weit zurück. Bereits die Griechen entwickelten die Idee der unzerteilbaren Atome, winziger Körper, aus denen alles im Universum aufgebaut sein sollte. Demokrit von Abdera postulierte bereits um 440 v. Chr., die Materie bestünde aus unteilbaren Körperchen, und nannte sie Atome, altgriechisch – atomos – unteilbar. Bereits sein Lehrer Leukipp hatte diese Ansicht vertreten, und es ist auch nicht ganz klar, ob er der Schöpfer der Idee war. Demokrit gilt nur deshalb als der Urheber, weil er sie in seinen umfangreichen Schriften ausführlich ver7 http://www.heise.de/tp/r4/artikel/2/2360/1.html

554


tritt. Aristoteles soll von ihm stark beeinflusst worden sein. Von ihm wiederum soll der Ausspruch stammen: »Das Ganze ist mehr als die Summe seiner Teile.« Dieser Satz ist geradezu zum Wahlspruch der Forscher um die zellulären Automaten geworden. Er liefert zwar keine Erklärung, hält jedoch einen überaus wichtigen Sachverhalt fest. Wenn man sich die Welt aus Atomen bestehend vorstellt – die, wie man damals dachte, durch ihre Form die Eigenschaften der makroskopischen Welt bestimmen –, fragt man sich unwillkürlich, was den Unterschied ausmacht zwischen einem ungeordneten Atomhaufen und einem Gegenstand. So bleibt die Erkenntnis nicht aus, dass außer den Bausteinen eines Körpers noch mehr zu ihm gehört. Wir würden heute sagen, die Struktur oder – für uns angemessener – die Information über seinen Aufbau gehört außer den Bausteinen auch noch zu einem Körper. Dennoch hat der Satz etwas Geheimnisvolles, und bis heute sieht man weit mehr darin als nur einen Hinweis auf die Existenz einer so ätherischen »Substanz« wie Information. Man postuliert Eigenschaften, die vorher nicht erkennbar waren. So entwickelte Konrad Lorenz den Begriff der Fulguration – aus dem lateinischen »fulgur« für »Blitz«. Für ihn steht der Begriff für Eigenschaften, die sich vorher noch nie zeigten, die nun jedoch plötzlich auftreten. Man kennt solche Effekte auch in der Genetik, wenn neue Eigenschaften, die vorher nicht ersichtlich waren, aufgrund eines Gendefekts auftreten. Lorenz nutzt die Fulguration auch im Zusammenhang mit Systemen, wenn Eigenschaften des Gesamtsystems auftreten, die sich nicht aus der Summe der Eigenschaften der Bestandteile definieren lassen. Ein ähnlicher Begriff ist Emergenz, er lässt sich aus dem lateinischen »emergere« für »auftauchen« herleiten. Ihn verwendet man konkret, wenn die Eigenschaften der mikroskopischen Bestandteile nicht ausreichen, um die Eigenschaften des makroskopischen Systems zu erklären. Das entspricht genau dem Bild, das man bei einem zellulären Automaten vor sich hat. Aus einfachsten Regeln der atomaren Bestandteile des Systems entsteht ein System aus Mustern, die sich nach komplexen Regeln richten, die eigentlich nirgendwo im System festgelegt wurden. Wo sind die Muster hergekommen und wo die Regeln, nach denen sie »leben«? Uns bleibt keine andere Erklärung als die, dass es Regeln gibt, die für Anhäufungen von »Atomen« gleich welcher Art gelten, dass rückgekoppelte Systeme nun einmal solche Muster und solches Verhalten zeigen, weil alle rückgekoppelten

555

13.4

13

Denkmaschine

Systeme es zeigen. Eine schlüssigere Erklärung haben wir bis heute nicht gefunden. Zelluläre Automaten sind eindeutig emergente Systeme, wir könnten sie sogar als emergente Automaten bezeichnen. Emergenz gibt es laut der Forschung in zwei Formen: einmal in der schwachen Form mit Effekten, die sich nur offensichtlich nicht aus den Eigenschaften der Elemente erklären lassen. In Wirklichkeit sind aber Erklärungen möglich, die wir nur noch nicht kennen. Die starke Form zeigt Eigenschaften, die sich keinesfalls aus den Eigenschaften der Elemente erklären lassen. Für viele ist jedoch zweifelhaft, ob es starke Emergenz überhaupt gibt, obwohl zelluläre Automaten eindeutig Automaten mit starker Emergenz zu sein scheinen. Aus der Eigenschaft, dass bei drei Nachbarn eine neue Zelle entsteht und eine Zelle bei zwei und drei Nachbarn bestehen bleibt, kann man noch lange nicht auf ein sich bewegendes Muster schließen oder auf Muster, die berechnungsuniversell sind. Nun wird es noch philosophischer: Die Frage ist, ob die Wahrnehmung dieser Eigenschaften (berechnungsuniverseller Muster) nicht vielmehr auf einer neuronalen Struktur unseres evolutionär und erfahrungsgebildeten Gehirns beruht? Also, ob dieses offensichtliche Bilden von Mustern nicht vielmehr nur in unserem Gehirn präsent ist und in der Realität nur die Eigenschaften der Atome existieren und sonst nichts? Alles makroskopisch Sichtbare wäre dann nur Interpretation unseres Gehirns, das nach den gleichen zellulären Automatismen arbeitet und deshalb Parallelen auf diese Weise sichtbar werden lässt. Wenn es für uns auch aussieht, als bewege sich ein Gleiter durch den Zellraum, so ist es doch offensichtlich, dass sich nicht wirklich etwas bewegt, sondern nur die Anordnung von Zellen geändert wird laut der beiden uns bekannten Regeln. Eine Erkenntnis, die zweifellos etwas Licht in die Funktionsweise unserer eigenen Welt wirft. Auch hier wird etwas in unserem Gehirn abgebildet, das doch offenbar in dieser Form gar nicht existiert. Kein roter Apfel ist wirklich rot, sondern ein Körper mit einer eigenen, warmen, an Feuer erinnernden Oberflächeneigenschaft. Es ist und bleibt ein Sinneseindruck, der erst in unserem Gehirn seine uns bekannte Form annimmt – eine Nachricht aus einer außerhalb von uns liegenden Welt, die uns für alle Zeiten fremd und unbegreiflich bleiben wird. Trotzdem hegen wir die Hoffung, dass Gedankenexperimente mit zellulären Automaten unsere Erkenntnis von der Welt vertiefen, und sei es auch nur um das winzige Stück des Schritts einer griechischen Landschildkröte, die sich mit Achilles auf ein schier aussichtsloses Rennen eingelassen hat. »Der perfekte Computer ist noch zu entwickeln. Man gibt seine Probleme ein, und sie kommen nie wieder heraus.« – Anonymus

556

Noch mehr Spaß: die große Kunst der kleinen Zellen

13.5

Noch mehr Spaß: die große Kunst der kleinen Zellen

Hat man ein leistungsfähiges Programm zur Simulation zellulärer Automaten, wie Golly, kann man natürlich tief in die Materie der »Muster des Lebens« eintauchen. Man kann all die Muster versuchen, die seit Conways Erstveröffentlichung gefunden und erforscht wurden. Einen schönen Überblick bietet das Life-Lexikon von Stephen Silver, aus dem die Muster durch Anklicken direkt in den Zellraum von Golly übernommen werden können. Hat man Golly gestartet, erreicht man es über diese Optionen: Help 폷 Live Lexicon. Es ist alphabetisch geordnet. Bereits das erste Muster unter A ist ein interessanter Oszillator, Achim’s P144, von Achim Flammenkamp.

Abbildung 13.28

Achim’s P144

Er hat eine Periode aus 144 Generationen, wofür auch die p144 (period 144) stehen. Wir hatten bereits erwähnt, dass man die Muster gruppieren kann, und folgende Einteilung gewählt: 왘

konstante Muster: Muster, die unverändert erhalten bleiben

왘

wiederkehrende Muster: Muster, die sich periodisch wiederholen (Oszillator)

왘

laufende Muster: Muster, die sich fortbewegen (Glider)

왘

chaotische Muster: Muster, die unregelmäßige Formen annehmen

Befasst man sich intensiver mit den Mustern, sind weitere Einteilungen möglich.

557

13.5

13

Denkmaschine

Besonders interessant sind bei den wiederkehrenden Mustern solche Muster, die Gleiter oder Schiffe ausstoßen. Es sind also keine richtigen Oszillatoren, sondern sogenannte Kanonen (guns). Bei den konstanten Mustern sind es vor allem die Fresser (eaters), die von großem Interesse sind. Es sind Muster, die Gleiter und andere Muster zerstören können, ohne dabei selbst zerstört zu werden. Im Programm Golly findet man eine schöne Auswahl im Pattern-Baum unter Still-Lifes. Bei wiederkehrenden Mustern unterscheidet man: 왘

Vulkane (vulcano) Muster, die wiederkehrende Änderungen zeigen, die nach außen gerichtet sind, eben wie ein Vulkan, der Lava ausstößt.

왘

Kanonen (guns) Muster, die Muster erzeugen, die sich fortbewegen. Es gibt Gleiterkanonen, die periodisch einfache Gleiter ausstoßen oder im Verbund Gleiter absetzen, aus denen beim Aufeinandertreffen z. B. Segler entstehen können.

왘

Brüter (breeder) Gebilde, die komplexere Muster hervorbringen. Das können durchaus konstante Muster sein. Ein Sonderfall sind die sogenannten Spacefiller, die direkt größere Flächen gleichmäßig ausfüllen. Bei Golly findet man sie unter Patterns 폷 Breeders.

Bei den laufenden Mustern unterscheidet man: 왘

Züge (trains) Muster, die aus zahllosen Gleitern oder Raumschiffen bestehen und sich in der Art eines Zuges fortbewegen.

왘

Dampfzüge (puffer-trains) Zug-Muster, die auf ihrem Weg Muster hinterlassen, die chaotisch oder geordnet sind und so an Dampfschwaden erinnern. Sie werden auch als Dampfer bezeichnet. Man findet sie in Patterns 폷 Puffers.

왘

Segler (ships) Ein Begriff, der hin und wieder auch für Gleiter genutzt wird. Allgemein nennt man größere Gleiter synonym auch Ships.

왘

Raumschiffe (spaceships) Noch größere Gleiter werden meist Spaceships genannt. Es gibt ein Verzeichnis Patterns 폷 Spaceships bei Golly, in dem sich einige interessante Formen befinden.

558

Von der Turingmaschine zu rechnenden Räumen

Bei den chaotischen Mustern wären in jedem Fall die Methusalahs zu erwähnen, Muster, die möglichst einfach sein sollen, jedoch zu möglichst zahlreichen Folgegenerationen führen, bevor alles erstarrt. Man findet sie unter Patterns 폷 Methusalahs. Ein weiteres interessantes Muster ist der Garten Eden. Ein Muster, das in dieser Form nicht im GoL entstehen kann. Das heißt, es gibt keine Generation vor dem aktuellen Zustand. Ein Garten Eden hat also in jedem Fall die Generationsnummer 0. Dass es solche Muster geben muss, war schon vor GoL bekannt. Sehr interessant sind auch die Metalösungen, die es in Golly zu bestaunen gibt. Man kann sie sich als GoL-Muster denken, die mit GoL simuliert werden. Um sie in Aktion zu sehen, sollte man Hyperspeed einschalten: Control 폷 Hyperspeed. Die Megapixel-Beispiele befinden sich unter HashLife. metapixel-galaxy.mc-gz ist die Metaversion von Kok's galaxy (p8), die von Jan Kok bereits 1971 entdeckt wurde. Mindestens genauso interessant ist die Turingmaschinen-Simulation, die es unter Golly zu bestaunen gibt: Patterns 폷 Signal-Circuitry 폷 Turing-Machine-3state.rle. Der Höhepunkt aller Simulationen ist zweifellos der Wireworld-Computer, die Simulation eines einfachen Digitalrechners mit einem zellulären Automaten. Die Simulation stammt von David Moore und Mark Owen. Man findet sie unter Patterns 폷 Other-Rules 폷 WireWorld 폷 primes.mc. Genauere Informationen gibt es auf der zugehörigen Homepage: http://www.quinapalus.com/wi-index.html.

13.6

Von der Turingmaschine zu rechnenden Räumen

Trotz zahlreicher bekannter Muster gibt es noch immer offene Fragen: 왘

Gibt es grenzenloses chaotisches Wachstum?

왘

Gibt es ein ganz einfaches Muster, ein Methuselah, auf das unendlich viele Generationen folgen, und wie sieht es aus?

왘

Gibt es wirklich kein Muster, das sich mit Lichtgeschwindigkeit bewegt?

왘

Wie sehen die Regeln für ein Universum aus, in dem sich Muster mit Lichtgeschwindigkeit bewegen können?

왘

Gibt es noch einfachere Regeln als die Regeln von Conway, die zu einem turingvollständigen zellulären Automaten führen?

559

13.6

13

Denkmaschine

왘

Führen alle Muster letztendlich zu stabilen Zuständen? (Auch oszillierende Muster sehen wir als stabilen Zustand an.)

왘

Gibt es Gleiter, die sich mit wechselnder Geschwindigkeit bewegen?

왘

Gibt es Muster, die sich selbst vervielfachen?

Ein Teil dieser Fragen ist bereits beantwortet worden, obwohl man die betreffenden Muster noch gar nicht kennt. Bereits Konrad Zuse war der Meinung, dass hinter den zellulären Automaten mehr stecken könnte, als man auf den ersten Blick erkennen kann. Sein Buch »Rechnende Räume« dokumentiert seine fantastischen Ideen zu zellulären Automaten und ihre Parallelen in der wirklichen Welt. Grundlage seines Ideengebäudes ist die Vorstellung, man könnte das ganze Universum auch als zellulären Automaten verstehen, natürlich als mehrdimensionalen. Die Elementarteilchen sind hier nur noch das Ergebnis der Funktionen dieses Automaten und nicht mehr die grundlegenden Bestandteile der Welt. Der Physiker und Informatiker Stephen Wolfram ist in Zuses Fußstapfen getreten und noch konkreter geworden. In dem revolutionären Buch »A new kind of Science« hat er seine Idee zu einer neuen Weltsicht ausgebaut. Das Buch kann auf seiner Homepage online gelesen werden: http://www.wolframscience.com/ nksonline. »Vielleicht haben wir die Welt längst verstanden. Wir haben nur noch nicht die Kraft gefunden, die Augen zu öffnen und der Wahrheit ins Gesicht zu sehen.« – Anonymus

13.7

Lesen Sie weiter


Beschreibung

http://www.quantencomputer.de/

Seite zu Quantencomputern

http://user.uni-frankfurt.de/~pospiech/ q_comp.html

Seite zu Quantencomputern der Universität Frankfurt

http://www.neuronalesnetz.de/

Einführung in neuronale Netze

www.neuronales-netz.de/ NeuronalesNetz.pdf

gute Einführung zu neuronalen Netzen

560

Lesen Sie weiter

URL

Beschreibung

http://library.lanl.gov/cgi-bin/getfile? number15.htm

Sonderheft Los Alamos Science, #15, 1987 zu Stanislaw Ulam

http://www.walenz.org/vonNeumann/ page0001.html

John von Neumann, Theory of SelfReproducing automata, University of Illinois Press, 1966

http://www.filmzentrale.com/rezis/ drseltsam.htm

Dr. Seltsam oder wie ich lernte, die Bombe zu lieben – filmische Karikatur von von Neumann

http://www.hsg-kl.de/faecher/inf/material/ Webseite zur Automatentheorie automaten/index.php http://www.horst-zuse.homepage. t-online.de/rechnender-raum.html

Zuse, Rechnender Raum

http://www.ibiblio.org/lifepatterns/ october1970.html

Artikel von Martin Gardner über Conways Life

http://www.csicop.org/si/9803/ gardner.html

ein Interview mit Martin Gardner

http://www.wolframscience.com/

offizielle Stephen-Wolfram-Seite

http://www.wolfram.com/ http://www.wolfram.com/products/ mathematica/index.html

Homepage des Programms »mathematica«

http://members.canb.auug.org.au/~dbell/

Artikel zu Life-Gleitern

http://www.fim.uni-linz.ac.at/lva/rus/ CellulareAutomaten/ca_theo.htm http://www.vlin.de/material/ ZAutomaten.pdf

Allgemeines zu zellulären Automaten

http://golly.sourceforge.net/ http://sourceforge.net/project/ showfiles.php?group_id=139354

SourceforgeNet-Seite zu Golly – Download

http://www.macupdate.com/info.php/id/ 19622/golly

Golly für MAC

http://www.bitstorm.org/gameoflife/ standalone/

GoL von Edwin Martin

http://members.tip.net.au/~dbell/

GoL von David Ingall

http://psoup.math.wisc.edu/Life32.html

Life32-Seite

561

13.7

13

Denkmaschine

URL

Beschreibung

http://www.ibiblio.org/e-notes/Life/ Game.htm http://www.mathwright.com/book_pgs/ book629.html http://www.cse.sc.edu/~bays/d4d4d4/

3D-Versionen im Internet

http://risais.home.comcast.net/~risais/ 3dca/3dca.htm

Liste von 3D-Versionen

http://cafaq.com/lifefaq/index.php

gute Linksammlung zum GoL

http://surf.de.uu.net/people/joke/rsc/ ships_toc.html#SEC2

Informationen zu Gleitern und Schiffen im GoL

http://www.ics.uci.edu/~eppstein/ca/ http://fano.ics.uci.edu/ca/

zur Frage, welche Systeme Gleiter haben

http://www.ics.uci.edu/~eppstein/ca/ search.html

Liste von Muster-Suchprogrammen

http://wwwhomes.uni-bielefeld.de/achim/ freq_top_life.html

Hitliste der GoL-Muster

http://www.quinapalus.com/wi-index.html

der Wireworld-Computer

http://www.heise.de/newsticker/ Das-Universum-als-zellulaerer-Automat--/ meldung/27361

Kurzartikel zu Wolframs Ideen vom Universum

http://www.ics.uci.edu/~eppstein/ca/ search.html

Suchprogramme für Life

Literatur zum Kapitel Kriesel, David: Ein kleiner Überblick über Neuronale Netze. 2007 (erhältlich auf http://www.dkriesel.com/).

562

ANHANG

»Ein Computer kann alles, was du willst, solange du nur willst, was er kann.« – Anonymus

Es gilt sich einen neuen Rechner zuzulegen, auf dem die Buch-Software eingerichtet werden kann – einen Rechner, auf dem beliebig installiert und deinstalliert werden kann. Außerdem darf er natürlich nicht viel kosten – kein Problem, er liegt mit auf der Buch-DVD.

A

VirtualBox (Windows / Mac OS X / Linux)

A.1

Installation und Anwendung von VirtualBox

Wer mit dem Begriff Virtualisierung nichts anfangen kann, sollte zuerst einmal das Kapitel dazu lesen (siehe Kapitel 11, »Virtualisierung«) – wenigstens so weit wie nötig, um zu verstehen, um was es geht. Nachdem wir das Prinzip der Virtualisierung verstanden haben, wollen wir es nun auf dem PC einsetzen, um unbeschadet Spaß mit dem Computer zu haben. Es geht darum, einen Rechner zur Verfügung zu haben, auf dem wir beliebig installieren und deinstallieren können. Dazu müssen wir die notwendige Virtualisierungssoftware erst einmal selbst installieren. Es ist die Software VirtualBox 1.6.0 von Sun. Wir verwenden sie schon deshalb, weil sie nicht als Server läuft und daher weniger kompliziert einzusetzen ist als beispielsweise VMware. Außerdem nutzen wir sie in einer älteren Version, weil mit den neueren Versionen nicht alle Beispielprogramme liefen. Auf der DVD (Software zum Buch/ Kap11/Virtuelle Maschinen/VirtualBox) befinden sich für Ihre Experimente zusätzliche Versionen, außerdem die Dokumentation als PDF-Datei (UserManual.pdf). Es ist zwar nicht das zurzeit am weitesten verbreitete Programm, aber es ist sehr leistungsfähig und bietet zahlreiche interessante Funktionen. Außerdem ist VirtualBox auch für den Mac und sogar für Linux erhältlich. Entsprechende Versionen enthält die beiliegende DVD im gleichen Verzeichnis, in dem die WindowsVersion liegt. Die Installation auf den unterschiedlichen Systemen ist fast identisch, so dass hier stellvertretend nur gezeigt wird, wie sie unter Windows läuft. Möchten Sie zusätzlich eine andere, neuere Version von VirtualBox einsetzen, müssen Sie zunächst die alte Version vollständig vom Rechner deinstallieren,

565

A


weil sonst keine der installierten VirtualBox-Versionen mehr läuft (siehe Abschnitt A.3 »VirtualBox deinstallieren«). Mit einer neueren Version von VirtualBox können Sie beispielsweise auch Windows 7 als Gastsystem betreiben.

A.1.1

Die Installation von VirtualBox

Informationen zum Programm VirtualBox gibt es auf http://www.virtualbox.org/. Das Handbuch finden Sie auf der DVD unter Software zum Buch\Kap11\Virtuelle Maschinen\VirtualBox\UserManual.pdf. Und die neueste Version hält im Internet diese Webseite bereit: http://www.virtualbox.org/wiki/Downloads. Möchten Sie die Software von der beiliegenden DVD laden, finden Sie sie hier: Software zum Buch\Kap11\Virtuelle Maschinen\VirtualBox\Version 1.6.0/VirtualBox-1.6.0-Win_x86.msi. Nach dem Start der Installation, die Sie durch einen Doppelklick auf die genannte Datei einleiten können, wird unter neueren Windows-Versionen (Vista/Windows 7) meist eine Sicherheitsabfrage angezeigt, die Sie bestätigen müssen. Danach wird wie üblich der Begrüßungsdialog geöffnet:

Abbildung A.1

Die Begrüßung zur Installation

Nach diesem Dialog wird die Lizenzvereinbarung angezeigt, die man akzeptieren muss, um die Installation weiter fortsetzen zu dürfen (siehe Abbildung A.2).

566


Abbildung A.2

Die Lizenz akzeptieren

Im folgenden Dialog wird gefragt, ob die USB- und die Netzwerkunterstützung mit installiert werden sollen, und auch, in welches Verzeichnis installiert werden soll. USB und Netzwerke installiert man, falls sie vorhanden sind. Wählen Sie das Verzeichnis auf einem Laufwerk mit viel freiem Speicherplatz, virtuelle Maschinen erzeugen riesige Dateien. Das Verzeichnis kann mit Hilfe der Browse-Schaltfläche (siehe Abbildung A.3) geändert werden.

Abbildung A.3

Die Frage nach USB-Unterstützung und Netzwerk

567

A.1

A


Vor Beginn der eigentlichen Installation wird noch einmal nach der Richtigkeit der Einstellungen gefragt; noch können nämlich mit der Back-Schaltfläche Korrekturen vorgenommen werden (siehe Abbildung A.4).

Abbildung A.4

Starten der eigentlichen Installation

Jetzt wird das Programm auf dem Rechner installiert (siehe Abbildung A.5).

Abbildung A.5

568

Die Installation läuft.


Während der Installation fragt die Software noch einmal, ob der USB-Support und die Netzwerkunterstützung installiert werden sollen. Die Dialoge können je nach Bedarf mit Installieren bestätigt werden (siehe Abbildung A.6).

Abbildung A.6

Die Frage nach dem USB-Support

Danach wird die Installation abgeschlossen, und das neu installierte Programm kann eingesetzt werden.

Abbildung A.7

A.1.2

Die Installation mit »Finish« abschließen

Der Einsatz von VirtualBox

Nach dem ersten Start zeigt uns VirtualBox eine Aufforderung zur Registrierung und einen Willkommensdialog mit einer leeren Liste, weil noch keine virtuelle Maschine angelegt ist. Anlegen können wir einen neuen Rechner über das Icon Neu oder das Menü Maschine 폷 Neu (siehe Abbildung A.8).

569

A.1

A


Abbildung A.8

Der erste Start von VirtualBox

Der nächste Dialog weist nur darauf hin, dass die Konfiguration eines neuen virtuellen Rechners durch einen Assistenten unterstützt wird. Im folgenden Dialog geht es darum, den Namen und den Typ des virtuellen Rechners festzulegen (siehe Abbildung A.9). Wählen Sie DOS als Typ des Betriebssystems aus.

Abbildung A.9

Den Namen und den Typ bestimmen

Im darauffolgenden Schritt kann die Größe des Hauptspeichers bestimmt werden. Für eine DOS-Installation sind 32 MB bei weitem ausreichend (siehe Abbildung A.10). Für übliche DOS-Programme werden davon 640 KB genutzt. Der restliche Speicher ist nur über spezielle Treiber für den erweiterten Speicher nutzbar.

570


Abbildung A.10

Die Größe des Hauptspeichers festlegen

Im Folgenden geht es noch darum, eine virtuelle Festplatte zu erstellen, die das zu installierende Betriebssystem aufnimmt (siehe Abbildung A.11). Klicken Sie dazu Neu... an. Auch die virtuelle Festplatte muss nicht sonderlich groß sein, kann jedoch als Dynamisch wachsend festgelegt werden, was keine zusätzliche Rechenleistung kostet (siehe Abbildung A.12). Im folgenden Dialog können Sie den Namen und die Startgröße festlegen. Wählen Sie einen Namen, aus dem das zu installierende System zu ersehen ist (siehe Abbildung A.13).

Abbildung A.11

Die neue, virtuelle Festplatte erstellen

571

A.1

A


Abbildung A.12

Als Typ eine dynamisch wachsende Platte wählen

Abbildung A.13

Den Namen und die Größe der Festplatte bestimmen

Danach kehrt die Installation zum Dialog mit der Festplattenauswahl zurück. Die neu erstellte Platte ist bereits ausgewählt und der Konfigurationsvorgang kann mit Weiter fortgesetzt werden (siehe Abbildung A.14). Abschließend werden die durchgeführten Einstellungen in einer Zusammenfassung angezeigt (siehe Abbildung A.15). Von diesem Dialog aus können Sie mit der Schaltfläche Abschließen die Erzeugung des virtuellen Rechners starten. Abschließend wird wieder der Ausgangsdialog angezeigt, nur wird dieses Mal

572


der erzeugte virtuelle Rechner in der Liste aufgeführt – in unserem Beispiel FreeDOS (siehe Abbildung A.16).

Abbildung A.14

Die Festplatte ist erstellt und ausgewählt.

Abbildung A.15

Die Übersicht über die eingestellten Parameter

Wird der virtuelle Rechner nun gestartet, geschieht dies nur aus Testgründen. Richtig funktionieren wird er erst, wenn wir ihm ein Betriebssystem zur Installation zur Verfügung stellen. Starten lässt er sich entweder über das Icon Starten oder durch einen Doppelklick auf die blaue Zeile in der Liste, in der er als ausgeschalteter virtueller Rechner angezeigt wird (siehe Abbildung A.16).

573

A.1

A


Abbildung A.16

Der neue virtuelle Rechner ist verfügbar.

Wichtig ist zu wissen, dass die Steuerung auf den virtuellen Rechner übergehen kann und man ihn nur mit der Taste (AltGr) verlassen kann. Man bezeichnet diese Tastenkombination auch als Host-Taste. Sie wird im Dialog unten rechts angezeigt, denn sie kann vom Nutzer geändert werden.

Abbildung A.17

Starten der neuen virtuellen Maschine

Ein Startassistent wird aktiviert und führt über einen Begrüßungsdialog (siehe Abbildung A.17) zum Auswahldialog für das Installationsmedium (siehe Abbildung A.18). 574


Abbildung A.18

Wir booten von einem CD-ROM-Laufwerk.

Hier lassen wir die Einstellung unverändert, weil wir nur einen Test ausführen. Nach dem Anklicken der Weiter-Schaltfläche versucht der virtuelle Rechner, über das CD-ROM-Laufwerk zu booten, was misslingen muss und zu einer entsprechenden Meldung führt:

Abbildung A.19

Ein bootfähiges Medium fehlt.

Somit ist unser wichtigstes Virtualisierungsprogramm installiert. Es wird unter Linux oder Mac OS X genauso installiert und läuft dort genau wie unter Windows. Sollte Sun VirtualBox wider Erwarten nicht funktionieren, kann man natürlich auf eines der anderen Systeme wie VMware oder Xen ausweichen.

575

A.1

A


A.2

Kommunikation mit dem Wirt

Was bringt ein virtueller Rechner, der im Betriebssystem läuft, aber keine Daten von der echten Festplatte lesen kann? Wahrscheinlich nicht viel. Deshalb gibt es verschiedene Möglichkeiten, Daten vom und zum virtuellen Rechner zu übertragen.

A.2.1

Wechseldatenträger

Das Gast-Betriebssystem ist in der Lage, die CD/DVD-Laufwerke des Wirts mit zu nutzen.

A.2.2

Gemeinsamer Ordner

VirtualBox bietet die Möglichkeit, sich einen Ordner mit dem Wirts-Betriebssystem zu teilen. Dazu wird ein bestehender Ordner des Wirtssystems über die Netzwerkfreigabe im Gastsystem sichtbar gemacht. Dazu muss die virtuelle Maschine abgestellt sein. In diesem Moment sind die Geräte in der Detailliste anklickbare blaue Links.

Abbildung A.20

Gemeinsamen Ordner einrichten

Wählen Sie Details 폷 Gemeinsame Ordner. Anschließend können Sie mit dem Plus-Icon einen Ordner aus dem Wirts-Dateisystem als neuen gemeinsamen Ordner hinzufügen (siehe Abbildung A.20). 576

VirtualBox deinstallieren

Nun müssen Sie im Gastsystem (bei Windows-Gastsystemen) den gemeinsamen Ordner noch verfügbar machen. Der Ordner ist als Netzwerkfreigabe greifbar, der Name des Netzwerkdevices ist vboxsvr. Je nach Gastsystem wird er entsprechend freigegeben. Wählen Sie bei älteren Windows-Versionen diese Menüfolge: Extras 폷 Netzlaufwerk verbinden. Nun müssen Sie noch den Laufwerksbuchstaben festlegen: Ordner: \\vboxsvr\. In einfachen DOS-Systemen wie dem eben eingerichteten DOS-Rechner haben wir diese Möglichkeit nach der DOS-Installation natürlich nicht.

A.3

VirtualBox deinstallieren

Die Deinstallation der Virtualisierungssoftware läuft auch nicht anders ab als bei üblicher Software. Man sollte sie in jedem Fall mit Hilfe der Softwarefunktionen der Systemsteuerung durchführen: Startmenü 폷 Systemsteuerung 폷 Icon Programme und Funktionen. Es wird eine Liste der auf dem Rechner installierten Software angezeigt (siehe Abbildung A.21). Wählen Sie das zu deinstallierende Programm aus (z. B. Innotek VirtualBox) und starten Sie mit RMT 폷 Deinstallation die Deinstallation. Nach einer Sicherheitsabfrage wird die Software vom Rechner entfernt.

Abbildung A.21

Die Deinstallation

Allerdings bleiben die Definitionen der eventuell angelegten virtuellen Rechner bestehen, und bei der Installation einer anderen Version von VirtualBox kann es möglicherweise zu Problemen kommen. Möchten Sie dies verhindern, sollten Sie das Verzeichnis .VirtualBox im Ordner C:\Users\ löschen. 577

A.3

A


A.4

Lesen Sie weiter


Beschreibung


Homepage von VirtualBox

http://de.wikipedia.org/wiki/VirtualBox

Wikipedia-Seite zu VirtualBox

http://www.pro-linux.de/berichte/ virtualbox.html

Linux-Seite zu VirtualBox

http://wiki.ubuntuusers.de/VirtualBox

VirtualBox unter Ubuntu

http://www.pc-magazin.de/praxis/cm/ page/page.php? table=pg&id=7471

Artikel zu VirtualBox

http://de.opensuse.org/VirtualBox

informative VBox-Seite von OpenSUSE

http://www.linuxforen.de/forums/ showthread.php?t=236444

umfangreiche Anleitung

http://ww1.4hf.de/2008/08/ virtualisierung-desktop-virtualisierung-imvergleich.html

Vergleich zwischen den gängigsten Virtualisierungstools

http://blog.kuerbisfeld.de/windows-7-beta- IMac, VirtualBox und Windows 7 auf-mac-apple-mit-virtualbox/222/ http://www.macwelt.de/schwerpunkt/v/ virtual-box

578

VirtualBox für Mac – Übersicht

Keine Sprache hat sich in den letzten Jahren so etabliert wie Java. Deshalb werden wir hier auch Java-Programme verwenden. Das Java-Grundpaket ist in zwei Ausführungen erhältlich, als JRE und als JDK. Hierbei handelt sich einmal um die virtuelle Maschine und einmal um die Entwicklungsumgebung mit der virtuellen Maschine. In diesem Kapitel wird die Installation von JDK mit JRE gezeigt. JRE ist erforderlich, um die Java-Beispielprogramme starten zu können. Möchte man jedoch in den Programmcode hineinschauen und ihn verändern, benötigt man das JDK. Es ist ebenfalls erforderlich, um die Entwicklungsumgebung Eclipse zu installieren.

B

Die Installation von Java und JRE

B.1

JDK oder JRE?

Virtuelle Maschinen haben wir in Anhang A, »VirtualBox (Windows / Mac OS X / Linux)«, bereits kennengelernt. Eine solche Maschine gibt es bei Java ebenfalls, allerdings in einer anderen Form – nicht als virtuellen Rechner, sondern als Plattform für Java-Programme. Bei Java ist es ein lauffähiges Programm namens java.exe. Es gehört zur JRE (Java Runtime Environment), der Java-Laufzeitumgebung. Mit diesem Programm lassen sich Java-Programme ausführen. Im einfachsten Fall sieht das so aus: java.exe c:\entwicklung\MyProgramm

Das bedeutet, der virtuellen Java-Maschine (java.exe) muss mitgeteilt werden, welches Java-Programm sie ausführen soll (c:\entwicklung\MyProgramm.class). Dass solch ein Programm erforderlich ist, um Java-Programme auszuführen, liegt daran, dass diese Java-Programme von der virtuellen Maschine interpretiert werden. Natürlich ist java.exe die Basis jeder Java-Installation. Wenn es nur die Datei java.exe wäre, dürfte man eigentlich nicht von Installation reden. Aber es gehört noch eine Reihe von Klassen dazu, die die VM benötigt, um Java-Programme ausführen zu können. Diese Klassen sind Standardklassen, die bereits von Oracle/ Sun mitgeliefert werden und so allgemeingültig sind, dass sie in fast jedem JavaProgramm erforderlich sind. Welche das sind, kümmert uns wenig. Es reicht zu wissen, dass die JRE-Software vollauf genügt, um alle üblichen Java-Programme

579

B


starten zu können. JDK ist dagegen für Java-Entwickler und enthält den Compiler und andere Entwicklerwerkzeuge. Die JRE ist immer im JDK enthalten.

B.2

Hardwarevoraussetzungen

Eine aktuelle JDK-Version belegt etwa 132 MB Festplattenplatz, ohne die umfangreiche API-Dokumentation. Für die Dokumentation lassen sich noch einmal 180 MB dazurechnen. Die genauen Angaben für das JDK: Baustein

Plattenplatz

Development Tools Entwicklungswerkzeuge werden unbedingt benötigt, wenn man Java programmieren möchte.

132 MByte

Demos Die Beispiele und Demos zeigen sehr eindruckvoll die Möglichkeiten dieser Sprache, so dass wir sie uns in jedem Fall anschauen sollten.

24 MByte

Source Code Quellcode der J2SE-Klassen; ist für uns nicht erforderlich. Lediglich erfahrene Java-Kenner sollten ihn installieren.

27 MByte

Public JRE 98 MByte Das ist die erwähnte JDK interne JRE, die wir in jedem Fall installieren. Dafür verzichten wir auf die Installation der separaten JRE. Tabelle B.1

Benötigter Plattenplatz für das SDK 6

Sollte der Plattenplatz für das JDK nicht genügen, so ist es ausreichend, die JRE zu installieren. Der erforderliche Plattenplatz geht aus der folgenden Tabelle hervor. Die gleichen Angaben für die JRE sind: Baustein

Plattenplatz

J2SE Runtime Environment (Java-Laufzeitumgebung 6) Mit den europäischen Sprachen; wird unbedingt benötigt.

72 MByte

Support for Additional Languages (Unterstützung für zusätzliche nichteuropäische Sprachen) Wird nur in den seltensten Fällen benötigt.

20 MByte

Zusätzliche Schriften und Medienunterstützung Werden nicht unbedingt benötigt, sollten jedoch installiert werden, sofern Platz vorhanden ist.

6 MByte

Tabelle B.2

580

Benötigter Plattenplatz für die JRE 6

Die Installation

Wie bei Java üblich werden alle gängigen Betriebssysteme unterstützt. Die Installation ist jedoch unter allen Betriebssystemen fast identisch, so dass wir darauf einzugehen brauchen.

B.3

Die Installation

Das Java 6 JDK oder das neuere Java 7 JDK kann von der Oracle/Sun-Java-Homepage gezogen werden: http://www.java.com/de/download/. Das JDK und die JRE für Windows befinden sich auch auf der beiliegenden DVD. Die Versionen sind etwas älter, aber ausgereift und liegen unter Software zum Buch\Anhang\Installationen\Java. Neuere Versionen und Versionen für andere Betriebssysteme kann man über das Internet beziehen. Diese Software wird von Oracle/Sun kostenfrei auf der Homepage angeboten (siehe Abbildung B.1). Die Webadressen sind in einer Tabelle am Ende dieses Kapitels aufgeführt. Sollten Sie ein anderes Eclipse mit dem JDK betreiben wollen, machen Sie sich zuvor im Internet kundig, ob die verwendete Eclipse-Version mit dem JDK läuft, das Sie downloaden möchten.

Abbildung B.1

Die Java-Download-Seite der Oracle/Sun-Homepage

581

B.3

B


Auf der DVD sind die Softwarepakete so zusammengestellt, dass sie problemlos laufen. Falls Sie aktuellere oder andere Versionen aus dem Internet beziehen, müssen Sie einiges beachten: Für Eclipse der Version 3.x ist wenigstens ein JDK oder JRE der Version 1.4.x erforderlich. Diese Version der virtuellen Maschine benötigt Eclipse, weil es auch in Java geschrieben ist. Für die Entwicklung ist ein JDK erforderlich. Dieses braucht nicht der genannten Versionsnummer zu entsprechen. Eine der neuesten Versionen ist z. B. die Java-Edition 6.0. Oracle/Sun unterscheidet dabei die Java-Umgebungen SE und EE. 왘

SE steht für Standard Edition, also Standardausführung.

왘

EE steht für Enterprise Edition, was sich mit Sonderausführung übersetzen lässt.

Außerdem gibt es noch eine ME-Ausführung, wobei ME für Micro Edition steht. Dieses Java-Programm eignet sich in erster Linie für kleine, mobile Geräte. Hauptanwendungsfeld sind Handys, PDAs u.Ä. Während SE dazu verwendet wird, Applikationen und Applets zu erstellen, lassen sich mit der EE-Version verteilte Anwendungen programmieren. Man spricht von EJBs, Enterprise Java Beans.

Abbildung B.2

Der Aufbau von Java

Zum Erlernen von Java genügt in jedem Fall fürs Erste die Standardversion. Erst wenn es darum geht, Software zu erstellen, die als verteilte Anwendung läuft, mit einem Applikationsserver zusammenarbeitet oder sich in einen Server und Clients gliedert, ist J2EE unverzichtbar. Das JDK wie die JRE findet man im Netz auf den Seiten von Oracle/Sun: http:// www.oracle.com/technetwork/java/index.html unter downloads in Form einer exe-Datei mit interner Installationsroutine.

582

Die Installation

Die Installationsdatei kann z. B. jdk-6u3-windows-i586.exe heißen. Hinter der Bezeichnung jdk folgt die Version (6u3) und danach das Betriebssystem, in diesem Fall Windows. Zum Schluss wird der Prozessor genannt. Hier handelt es sich also um eine Windows-Version für den Intel 586. Man sollte darauf achten, dass man sich die richtige Software zieht, denn Java ist sehr stark gegliedert und umfangreich. Die Enterprise-Version, die man auch über ein Icon auswählen kann (siehe Abbildung B.3), wird beispielsweise in einem Schaubild gezeigt.

Abbildung B.3

Der Link zu den Download-Seiten von J2EE

Diese Version ist jedoch für eine Einführung in Java wirklich nicht erforderlich, weil man, um Enterprise Java Beans entwickeln zu können, schon über fundierte Erfahrungen mit Java verfügen muss. Ein älteres Schaubild zeigt jedoch sehr schön, worauf es ankommt (siehe Abbildung B.4).

Abbildung B.4

Die Software-Pakete der J2EE in einer Grafik für die alte Version 1.4

Man sieht deutlich, dass es nicht genügt, nur das SDK zu installieren. Eine vernünftige Dokumentation sowie aussagekräftige Beispiele sind ebenfalls nützlich. Oracle/Sun empfiehlt, bei der J2EE sogar das Tutorial (Lehrbuch) zu nutzen. Fangen wir also mit der Installation des SDK an.

583

B.3

B


Es befindet sich auf der DVD unter \Software zum Buch\Anhang\Installationen\ Java als jdk-6u3-windows-i586-p.exe (siehe Abbildung B.5). Durch einen Doppelklick kann sie aus dem Datei-Explorer heraus gestartet werden.

Abbildung B.5

Die SDK-Software auf der Buch-DVD

Nachdem die exe-Datei gestartet wurde, wird zunächst das Installationsprogramm aktiviert:

Abbildung B.6

Die Installation des JDK von Java 6

Danach müssen die Lizenzbestimmungen akzeptiert werden (siehe Abbildung B.7). Zum Bestätigen klicken Sie auf die Schaltfläche Accept. Akzeptiert man sie nicht (Decline-Schaltfläche), wird noch einmal nachgefragt und sofort die Installation abgebrochen.

584

Die Installation

Abbildung B.7

Die Lizenzbestimmungen müssen beachtet werden.

Nach der Lizenzbestätigung öffnet das Installationsprogramm eine Setup-Dialogbox, in der der Zielpfad ausgewählt (Change...) und die Software festgelegt werden kann, die installiert werden soll:

Abbildung B.8

Die zentrale Dialogbox der JDK-Installation

Für die Beispiele des Buches wurde die JRE in C:\Software\Java\jdk1.6.3\ abgelegt. Folglich ist dieser Pfad bei der Beispielinstallation als Zielpfad angegeben worden. Die Installationsroutine schlägt den Pfad C:\Program Files\Java\ jdk1.6.0_03\ vor. Die Schaltfläche, mit der der vorgeschlagene Pfad geändert werden kann, heißt Change... Neben der Combobox gibt es zwei kleine Schaltflächen: Mit One Level Up gelangt man jeweils eine Verzeichnisebene zurück. Mit Create New Folder kann man neue Unterverzeichnisse anlegen. Der im Folder name-Feld eingege-

585

B.3

B


bene Pfad wird bereits in den Verzeichnissen angezeigt, auch wenn er noch gar nicht existiert. Er ist an dem Karteikartensymbol mit dem Sternchen zu erkennen, das sich auch auf der Create New Folder-Schaltfläche befindet. Es genügt der genaue Pfadeintrag im Folder name-Feld. Das Anlegen von Pfaden ist nicht erforderlich. Mit OK wird der angegebene Pfad übernommen.

Abbildung B.9

Das Einstellen des Installationsverzeichnisses

Ohne Veränderungen im Feld für die Softwareauswahl des Dialogs von Abbildung B.8 ist alles ausgewählt. Sofern der Platz auf der Festplatte ausreicht, kann man die Auswahl so lassen. Den benötigten Plattenplatz zeigt Tabelle B 1. Demos and Samples und Public JRE sollten in jedem Fall installiert werden, da wir diese brauchen. Am ehesten kann noch auf die Pakete Source Code und Java DB verzichtet werden (siehe Abbildung B.10). Zum Abwählen eines Pakets klicken Sie auf das Laufwerksymbol neben dem Paketnamen und wählen in dem sich öffnenden Kontextmenü den Menüpunkt Don’t install this feature now. aus.

Abbildung B.10

Der Sourcecode soll nicht installiert werden.

Der nächste Dialog wird angezeigt. Es ist eine Fortschrittsbar (Progressbar). Je nach Rechnerleistung sollten die Entwicklerwerkzeuge innerhalb einer Minute installiert sein. 586

Die Installation

Abbildung B.11

Die Installation der Entwicklerwerkzeuge

Man sollte sich nicht wundern, wenn man nun einen Dialog angezeigt bekommt, der stark an Abbildung B.8 erinnert. Es ist das Custom Setup der JRE (siehe Abbildung B.12). Leider ist er nicht sofort als solcher zu erkennen, was schnell dazu verleiten kann, einen Fehler zu machen, indem man an dieser Stelle abbricht. Hier sollte man auch den gewünschten Installationspfad angeben. Im Buch wird dazu ebenfalls C:\Software genutzt, so dass diesmal im Install to: oder auch Folder name: stehen sollte: C:\Software\Java\jre1.6.3\.

Abbildung B.12

Die Einstellungen für die JRE

Nachdem der Installationspfad entsprechend eingestellt ist, geht es mit der NextSchaltfläche weiter. Die Einstellungen der Software wie Java (TM) SE Runtime Environment kann man so belassen. In einem weiteren Dialog sehen Sie einen Fortschrittsbalken, und die Installation wird nun mit dem Kopieren der JRE und der Plugins für Browser auf die Festplatte abgeschlossen. Der erfolgreiche Abschluss der Installation wird wiederum mit einem speziellen Dialog angezeigt. Mit der Finish-Schaltfläche wird er geschlossen, und die Installation ist beendet.

587

B.3

B


Möchten Sie auf einem anderen Rechner lediglich Java-Programme ausführen, ohne Software zu entwickeln, genügt es, wenn Sie dort das JRE-Paket installieren. Auch wenn es ein Teil des JDK ist, kann es mit Hilfe des Custom Setup-Dialogs nicht separat installiert werden. Hier bleibt bei den Anwenderrechnern nur die getrennte Installation mit dem JRE-Paket. Dieses Installationsprogramm finden Sie auch auf der beiliegenden DVD-ROM im Verzeichnis \Software zum Buch\Anhang\Installationen\Java, und es heißt jre-6u2-windows-i586-p-s.exe.

Abbildung B.13

B.3.1

Die Installation ist abgeschlossen.

Die Installation der Dokumentation

Zum JDK gehört eine umfangreiche englische Dokumentation, man spricht auch von der Dokumentation des Java-API. Meist liegt diese Dokumentation als gepackte Datei ohne Installationsroutine vor. Sie wird einfach entpackt, und zwar am besten ins JDK-Verzeichnis. In der Beispielinstallation kommt sie also ins Verzeichnis C:\software\Java\jdk1.6.3\docs. Auf der DVD liegt die Dokumentation im Verzeichnis \Software zum Buch\ Anhang\Installationen\Java und trägt den Namen jdk-6-doc.zip. Sie besitzt ein Unterverzeichnis \docs\ und braucht nur ins jdk1.6.0-Verzeichnis entpackt zu werden. Falls kein Entpackprogramm installiert ist, kann das Programm fz301.exe aus dem Verzeichnis \Tools\Packer von der DVD-ROM genutzt werden. Beachten Sie jedoch bitte die Lizenzbestimmungen. Aufbau der JDK-Dokumentation Auch wenn man kein Java programmieren möchte, sollte man sich nach der Installation die API-Dokumentation unbedingt ansehen. Sie ist ein wirklich vor-

588

Die Installation

bildlich gestaltetes API-Dokument. Die Möglichkeiten der Sprache Java lassen sich damit wunderbar erkennen und untersuchen. Wechseln Sie im Datei-Explorer in das Verzeichnis c:\software\java\jdk1.6.3\ docs, und öffnen Sie die Datei index.html in einem Browser. Es ist mit Sicherheit die umfangreichste zusammenhängende Literatur zu Java. Wobei man zugeben muss, dass ein Teil nur über das Internet verfügbar ist. Überall dort, wo am rechten Rand docs steht, sind die Dokumentationstexte im docs-Verzeichnis auf der Platte verfügbar. Und überall dort, wo download steht, bekommt man nur etwas zu sehen, wenn man online ist und der Browser die jeweilige Seite von Oracle/Sun beziehen kann. Der Download-Link erlaubt es, die Seiten dauerhaft auf die Festplatte herunterzuladen.

Abbildung B.14

Ein erster Einblick in die API-Dokumentation

Der wichtigste Teil ist die eigentliche API-Dokumentation, die man etwas unterhalb unter API, Language, and Virtual Machine Documentation als Java Platform API Specification findet. Nach einem Klick auf diesen Link sollte eine dreigeteilte Webseite zu sehen sein (siehe Abbildung B.14). Mit diesen Erläuterungen müssen sich Java-Programmierer ständig herumschlagen. Auf der linken Seite findet man einen Überblick über alle vorhandenen Klassen und die Pakete, in denen sie abgelegt sind. Rechts wird alles ausführlich erläutert, wobei die Möglichkeiten der Verlinkung der Texte als

589

B.3

B


Hypertext in HTML phantastisch gelungen sind. In Java gibt es dafür ein spezielles Werkzeug, Javadoc, das solche Dokumente automatisch aus den Java-Quellen generieren kann.

B.3.2

Demos und Beispiele

Mit dem JDK sind eine ganze Reihe von Demos und Beispielen installiert worden, die einen guten Einblick in die Möglichkeiten der Sprache Java bieten. Genau aus diesem Grund haben wir das ganze Paket installiert. Wir werden uns die Beispiele nur kurz anschauen. Am einfachsten ist der Start per Datei-Explorer. Die Datei C:\Software\Java\ jdk1.6.3\demo\applets.html wird mit dem Browser geöffnet, für den ein Plugin installiert wurde:

Abbildung B.15

Die Demo-Applets werden über die Webseite gestartet.

Auf der Seite befinden sich eine ganze Reihe von Links zu Demoprogrammen, die einen Querschnitt der Möglichkeiten zeigen, die ein Programmierer mit Java hat. Viele Applets bieten Interaktionen, z. B. Bewegung der Objekte mit Hilfe der Maus (siehe Abbildung B.16). Zur Ansicht simulierter Modelle aus der Chemie klicken Sie z. B. auf die Datei C:\ Software\Java\jdk1.6.3\demo\applets.html. Nachdem sich die Webseite geöffnet hat, klicken Sie den Link 3D Chemical Models example2 an. Unter Umständen

590

Die Installation

wird am oberen Rand des Webfensters eine Bemerkung angezeigt: »Das Ausführen von Scripts bzw. ...« Das heißt im Grunde genommen, dass das Java-Applet gar nicht angezeigt wird. Dazu muss auf die gelbe Fläche geklickt und im PopupMenü die Option Geblockte Inhalte zulassen aktiviert werden.

Abbildung B.16

Educational Applets – 3D Chemical Models

Es wird noch einmal nachgefragt – hat man erneut zugestimmt, wird endlich die simulierte Kugel aus Kohlenstoffatomen angezeigt. Es handelt sich um C60, ein sogenanntes Fulleren. Das sind Moleküle aus Kohlenstoff, die die Form einer Kugel oder einer Röhre haben können. Packen Sie den Fußball aus Atomen mit gedrückt gehaltener Maustaste an irgendeiner Stelle, und Sie können das Molekül beliebig hin und her bewegen. Es handelt sich bei dem Programm um ein Applet, ein kleines Java-Programm, das von einem Browser ausgeführt werden kann. Wie eine Webseite wird es von einem Internetserver bezogen, kann also durch das Netz übertragen werden. Diese Art Programm war bereits bei der Entwicklung von Java im Gespräch und sollte die eigentliche Basis der Java-Euphorie werden. Bis heute haben sich die Applets allerdings nur bedingt durchgesetzt. Unterhalb des Applet-Fensters gibt es den Link The Source. Klicken Sie diesen an, wird die dazugehörige Java-Datei angezeigt. Wer genauer hineinschaut, bekommt anhand der Kommentare mit, dass die Datei von einem gewissen James Gosling stammt. Das ist niemand anders als der Leiter der Projektgruppe, die Java entwickelt hat, sozusagen der Erfinder der Sprache Java. Damit haben wir einen Trip zu den Anfängen von Java, ja bis zum Erfinder selbst gemacht. Bei noch

591

B.3

B


genauerem Hinsehen lässt sich feststellen, dass es nirgendwo Codeanteile gibt, die eine solche Kugel zeichnen. Gosling wäre kein guter Programmierer, wenn er den Aufbau der Kugel fest in den Code integriert hätte. Natürlich hat er kein Programm geschrieben, das jede Art von chemischem Molekül darstellen kann. Sein Programm sorgt nur dafür, dass die Kugel gezeichnet und die Ereignisse für die Bewegungssteuerung abgearbeitet werden. Wo aber kommt die Kugel her? Applets werden vom HTML-Code einer Webseite aufgerufen und die erforderlichen Parameter von dort mitgegeben. Das nehmen wir mal unter die Lupe: Klicken Sie mit der rechten Maustaste in die Webseite, und wählen Sie den Menüpunkt Quelltext anzeigen. Nun wird der HTML-Code in einem Texteditor angezeigt. Das Applet findet man zwischen den HTML-Anweisungen relativ gut. Die Größe wird angegeben und als Parameter namens model eine Datei models/ buckminsterfullerine.xyz. MoleculeViewer (example 2) <param name=model value=models/buckminsterfullerine.xyz>

Auch diese Datei sollten wir uns einmal mit einem Editor ansehen, und zwar unter C:\Software\Java\jdk1.6.3\demo\applets\MoleculeViewer\models. # buckmisterfullerine http://chem.leeds.ac.uk/Project/MIME.html 60 C 1.22650000 0.00000000 3.31450000 C 0.37900000 1.16640000 3.31450000 C -0.99220000 0.72090000 3.31450000

Wie zu sehen, enthält eine solche Datei zunächst die Anzahl der Atome und für jedes Atom in einer Zeile das Kurzzeichen des Atoms, seine Position im Molekül als Koordinatenwert aus X,Y,Z. Nun ist auch die etwas seltsame Dateiendung etwas einleuchtender, die James Gosling gewählt hat. Natürlich ist ein Ball aus 60 Atomen nicht gerade einfach zu beschreiben, zumal, wenn man die Lage der Atome im Raum angeben muss. Um die Arbeitsweise des Programms besser zu verstehen, sehen wir uns ein einfacheres Beispiel an: Wasser. Es ist die Datei water.xyz. # o h h

water -- this is *wrong* 0 0 0 -1 1 0 1 1 0

Just a guess

Wasser, bekanntlich H2O, besitzt ein Sauerstoffatom, an dem wie zwei Ohren zwei Wasserstoffatome angelagert sind. Setzen wir den Sauerstoff genau auf

592

Die Installation

0,0,0, so können wir ein Atom links darüber setzen mit –1,1,0 und ein Atom rechts daneben mit 1,1,0. Es ist also gar nicht so schwer.

B.3.3

Die Installation von Eclipse

Nachdem Sie erfahren haben, wie ein wirklicher Java-Profi Moleküle simuliert, wollen wir noch zeigen, mit welchen Werkzeugen die heutigen Java-Profis arbeiten. Das am häufigsten eingesetzte Entwicklungswerkzeug für Java heißt Eclipse und ist kostenlos erhältlich. Die Homepage zum Download der Software ist folgende: http://www.eclipse.org/downloads/. Die Software befindet sich auch auf der Buch-DVD im Verzeichnis /Software zum Buch/Anhang/Installationen/Eclipse. Die gepackte Datei heißt eclipse-java-europafall2-win32.zip. Zur Installation entpacken Sie einfach den Inhalt der Datei in ein Verzeichnis auf der Festplatte (z. B.: c:\software\java), das ist alles. Sollten Sie keines der gängigen Packprogramme wie z. B. winzip haben, finden Sie eins auf der DVD unter packer. Alle erforderlichen Einstellungen für die Installation nimmt Eclipse selbst beim ersten Start der Software vor. Ohne Java startet Eclipse allerdings nicht.

Abbildung B.17

Die Willkommensseite von Eclipse

593

B.3

B


Die Willkommensseite (siehe Abbildung B.17) bietet Links zu Lernprogrammen und wichtigen Informationen. Auch als Anfänger sollte man sich Eclipse einmal anschauen, um ein Gefühl dafür zu bekommen, mit welchen Werkzeugen heute Software entwickelt wird. Die weiterreichende Nutzung von Eclipse soll dem Java-Profi unter den Lesern überlassen bleiben. Er kann damit die gezeigten JavaBeispiele auf eigene Faust weiterentwickeln.

B.4

Deinstallation

Wenn man sich ausgiebig mit Java auseinandergesetzt hat oder weil man den Rechner für andere Software frei haben möchte, will man das JDK und das JRE auch wieder deinstallieren. Das gelingt mit den Hilfsprogrammen von Windows am besten, also über die Menüs Start-Icon 폷 Systemsteuerung 폷 Programme und Funktionen. In der großen Tabelle sollten sich zwei Zeilen zu Java befinden: ein Eintrag zum JDK und einer zur JRE. Die jeweilige Zeile, z. B. Java (TM) Development Kit 6 Update 3 oder Java (TM) 6 Update 3, wird angewählt und mit der Deinstallieren-Schaltfläche von der Platte geputzt.

Abbildung B.18

594

Die Deinstallation von JDK

Noch mehr Spaß am Programmieren: 3D-Moleküle

Die Dokumentation wird von Windows nicht entfernt, sie muss über den DateiExplorer auf herkömmliche Weise gelöscht werden. Sie befindet sich unter c:\ Software\jdk1.6.3\docs. Sollte außer der Dokumentation nichts mehr in dem jdk1.6.0-Unterverzeichnis sein, kann das ganze Verzeichnis gelöscht werden. Eclipse lässt sich genauso einfach deinstallieren, wie man es installiert hat. Das Eclipse-Verzeichnis wird einfach im Datei-Explorer markiert und dann gelöscht.

B.5

Noch mehr Spaß am Programmieren: 3D-Moleküle

Sie haben das wunderschöne 3D-Molekülprogramm von Gosling gesehen. Haben Sie dabei Lust bekommen, selbst einmal Moleküle zu bauen? Zweifellos das bekannteste und größte Molekülmodell ist das sogenannte Atomium in Brüssel. Es wurde 1958 von dem Architekten André Waterkeyn entworfen und stellt das Modell eines Ferritmoleküls in der kubisch raumzentrierten Form dar, in der ein Eisenatom in einem Würfel aus acht Eisenatomen eingeschlossen ist. Das Modell zeigt das Molekül in 165-milliardenfacher Vergrößerung. Wie das fertige Molekül aussieht, zeigt Abbildung B.19. Die Lösung finden Sie auf der DVD in Verzeichnis Software zum Buch\Noch mehr Spaß\Ferrit.

Abbildung B.19

Ein Ferrit-Molekül

595

B.5

B


B.6

Lesen Sie weiter


Beschreibung

http://www.oracle.com/technetwork/java/ index.html

Java-Homepage

http://download.oracle.com/javase/tutorial/ Java-Tutorial von Oracle/Sun www.java.com/en/download/ windows_automatic.jsp

Java-Download-Seiten

http://www.java.com/en/download/ index.jsp

Java-Download-Seiten

www.java.de/

deutsche Java-Seite

http://www.karakas-online.de/teia/JAVA/ java_1_1_1.htm

Java gestern – heute – morgen

http://de.wikipedia.org/wiki/Fullerene

Wikipedia-Seite zu den Fullerenen

http://blogs.sun.com/jag/

Gosling-Blog

596

Index .de 438 .NET 276, 281 32 Bit 329 3D-Shooter 367f. 3D-Spiele 387 6-Core-Prozessor 209

A A.M.I. 181 Abakus 32, 37 chinesischer 37 Abenteuerspiel 370, 376 Access 303 Acorn Archimedes 184 Ada (Programmiersprache) 83, 278 Adventure 377, 389 Adventuregame 370, 376 Akkumulator 117 Alexander der Große 49 ALGOL 255, 266, 273 ALGOL 68 256 Amazon 502f. Amazon Web Services 504 AMD 209 AMD Phenom II 197 Ameisen 289 America’s Army 368, 407 Amiga 182 Analog 39 Analoge Rechner 85 Analoguhr 39 Analytische Maschine 80 Andreessen, Marc 455 Antikythera 씮 Maschine von Antikythera AOL 457 Apache 316 API 589 API-Dokumentation 580, 588f. Apple 153, 173, 298, 458, 470 Logo 120 Apple I 153 Apple II 156, 179, 298, 306, 381 Apple iWork.com 504

Apple Lisa 160 Apple Macintosh 161 Apple MobileMe 504 Apple Records 154 Archimedes 396 Arcon 161 Aristander 49 Aristoteles 45f., 554 ARPANET 423, 427f. Ashton-Tate 302 Assembler 150, 241f. Atanasoff-Berry-Rechner 101 Atari 161, 172, 359 Atari ST 181 Atom 544, 554 Atomium 595 Automat 120 AWARD 181

B B (Programmiersprache) 268 Babbage, Charles 80, 100, 203 Backus, John W. 243 Baer, Ralph 359 Baldur's Gate 387 Ballerspiel 366 Ballmer, Steve 487 Bard's Tale 386 BASIC 169, 175f., 259, 274, 281, 289, 315 BBS 443 BCPL 268 Beatles 154 Bell Laboratories 268, 314, 321 Bell, Gordon 339 Berners-Lee, Tim 444f., 452, 458 Betriebssystem 320f., 323f., 327f., 330, 332f., 336, 338, 341, 571, 573 DOS 320, 323f., 326 QNX 340f., 343 Bildschirmschoner 218 Binäres Zahlensystem 27 BIOS 180

597

Index

Bit 169, 331 Blue-ray 44 Bob 301 BOINC 221, 230, 232 Borland 273, 311 Börries, Marco 308, 315, 335 Bot Client 214 Botnetz 213 Boulder Dash 179, 381, 390 Breakout 389 Brotkasten 169 Brown, Thomas 71 Browser 452 Browserkrieg 456 Brunsviga 69 Bulletin Board System 씮 BBS bwBASIC 259

C C (Programmiersprache) 268, 274, 314f. C# (Programmiersprache) 269 C++ (Programmiersprache) 268, 274, 276 C64 씮 Commodore C64 Canion, Joseph R. 190 Canonical Ltd. 335 Catacomb 386 CD 42 CDC 6600 204 Cerf, Vinton 427 CERN 216, 232, 445f., 452 Chrome 458, 460 Chrome OS 479 Church, Alonzo 254 Church-Turing-Hypothese 245, 254 CIA 307 Cipher Event 106 Cloud Computing 202, 461, 478, 484, 502, 507 Cloud-Betriebssystem 485 Cloud-Dienste 502 Cobol 110, 266 Coding4fun 175, 277, 283 Colossus 101, 107 Combobox 585 Commodore 161, 170, 182 Commodore C64 161, 168

598

Compaq 189 Compiler 243, 258 Computer 44 analoge 85 Computercluster 211, 503 Conway, John H. 531, 538 COSINE 429 CP/M 321, 327 CPC 127 Cray 205, 211 Cray Jaguar 207, 230 Cray, Seymour 203 Crocker, Steve 424 Crowther, William 376 Custom-Setup-Dialog 588 Cyberkriminelle 478

D da Vinci, Leonardo 61 Dahl, Ole-Johan 268 Daisyworld 505 DARPA 422, 427 DAU 씮 Digital-Analog-Umsetzer dBASE 302 Defender of the Crown 173, 405 Demokrit 554 DENIC 438 Der Ring der Nibelungen 175 Desktop-Virtualisierung 508 Diablo 387, 390 Die 192 Die Siedler 390 Difference Engine 80 Diffie, Whitfield 299 Digital 39 Digital Equipment Corp. 191 Digital-Analog-Umsetzer 43 Digitaluhr 39 DirectX 329 DNS 431, 434 Dodge, Dan 339 Domain 437 Domain Name System 씮 DNS Domaingrabbing 440 Domainname 429 Donkey Kong 367, 389 Doom 367, 386, 388, 390

Index

DOS 299, 320f., 323f., 326ff., 332, 443, 454, 466, 570, 577 DOS-Befehle 323 Drucker 169 DSL 44 Dualcore-Prozessor 202 Duke Nukem 3D 386 Dungeon Master 386 Dungeons und Dragons 384

Fortran 243, 266 FreeBSD 316 FreeDOS 264 FreePascal 274 French, Melinda 씮 Gates, Melinda FTP 452 Fulguration 555 Fuzzy-Logik 45 Fuzzy-Set-Theorie 46

E

G

Echtzeit 386 Echtzeitsystem 338 Eclipse 316, 339 Installation 593 Edison, Thomas Alva 41 EDSAC 101 Egoshooter 388, 413 Eisenhower, Dwight D. 422 Ellison, Larry 307 Emacs 315 E-Mail 315 Emergenz 555 Emulation 468 Emulatoren 175 ENIAC 101, 110, 321 Enigma 119 Enquire 446, 458 Enterprise Java Beans 582 Ethernet 315 Euklid 114 Euklidscher Algorithmus 114 Excel 300 eyeOS 492

Gaia 502, 504 Galilei, Galileo 61 Game of Life 112, 531, 545 Games 169, 173f., 315, 329, 351, 362, 507 Gates, Bill 158, 291, 299, 324f., 346, 478 Gates, Melinda 301 GEM 181, 327f. General Motors 346 Geschicklichkeitsspiel 367, 393 Gesetz vom ausgeschlossenen Dritten 46 GIMP 316, 335ff. Gleiter 537 Glider 537 Gnome 316 GNU 314ff. Gödel, Kurt 246, 254 Gödelscher Unvollständigkeitssatz 253f., 515 Google 458, 479, 486, 502f. Google App Engine 504 gOS 343, 480 Gosling, James 591 GOTO 112, 177 GOTO-Programmierung 255 GPU 225 Graetz, Martin 362 Grafische Oberfläche 181 Grammophon 41 Grid 502 Grid-Computing 216, 503 GUI 325 Gunter's Scale 33 Gunter, Edmund 35 Gygax, Gary 385

F F# (Programmiersprache) 287 Feedly 459 Ferranti 352 Fibonacci-Zahlen 114 Fiorina, Carly 191 Firefox 457f. Firewall 478 Fleißige Biber 252 Flock 460

599

Index

H

J

Hacker 313, 315 Half-Life 388 Hanse 173 Hardware 169, 320, 324, 329, 331f., 360 Hardware-Analysetool 238 Harris, Jim 190 Harry Potter (Spiel) 391 Heisenbergsche Unschärferelation 515 Hercules 130 Hexadezimalsystem 28 Hilbert, David 111, 246 Hinweise zur Nutzung des Buchs 16 Hitachi 46 Homecomputer 161, 168, 170, 313, 359 Hopper, Grace 109, 243, 266 HP 485 HTML 446, 452 Hybrid Mikrokernel 339

Jahr-2000-Problem 329 Jahr-2038-Problem 331 Java 113, 247, 250, 268f., 276, 283, 316, 320, 360, 581f., 584 EE 582 Installation 579 ME 582 SE 582 JDK 582, 590 Deinstallation 594 Dokumentation 588 Hardwarevoraussetzungen 580 Installation 579, 581 Jobs, Steve 153, 324, 484 Joystick 174f. JPC-Projekt 472 JRE 582 Deinstallation 594 Hardwarevoraussetzungen 580 Installation 579 Jurassic Park 391

I IBM 119, 125, 202, 289, 297, 306f., 309, 321, 328, 343 IBM 604 127 IBM 650 127 IBM Mark 1 128 IBM-DOS 298 IBM-PC 179, 298, 321 IC 148, 194, 200 ICANN 437 icloud 488 IMP 424 Indiana Jones 391 Intel 198 Intel Core i7-980X 197 Internet 422, 429 Internet Explorer 301, 455, 457f. Internet Protocol 씮 IP InterNIC 437 Interpreter 258 IP 315, 428 IP-Adresse 429 ISDN 44 ISDN-Karte 443

600

K Kahn, Philippe 311 Kahn, Robert 427 Kalter Krieg 421 KDE 316 Keilschrifttafel Zahlendarstellung 25 Kemeny, John George 259, 281 Kepler, Johannes 67 Kildall, Gary 321, 327 Kline, Charley 425 Knuth, Donald E. 315 Kubric, Stanley 112 Künstliche Intelligenz (KI) 522 Kurtz, Thomas Eugene 259, 281

L Laplace, Pierre-Simon 514 Laplacescher Dämon 514 Lara Croft 391 Lashlee, Hal 303

Index

Leibniz, Gottfried Wilhelm 72 Leibniz-Rechner 292 Lemmings 390 Lichtgeschwindigkeit 540 Life 112 Linné, Carl von 45 Linux 289, 314, 316, 321, 329, 331ff., 338ff., 453, 465, 470, 484 VirtualBox installieren 565, 575 Liste 336, 569, 573, 577 Lizenz 585 Localhost 450 Lochkarte 118, 127, 292 Loopback-Device 450 Lotus 306, 309 Lotus Notes 299 Lovelace, Ada 81, 83, 242, 279 Lovelock, James 505 Lucas, Edouard 257 Lynx 453

M Mac OS X 465 VirtualBox installieren 565, 575 Macintosh 씮 Apple Macintosh Mailbox 443 Make-Datei 263 Manchester Mark I 121 Maniac Mansion 173 Märchennetz 527 Mark I 101, 321 Maschine analog 45 digital 45 Maschine von Antikythera 51 Maschinensprache 239 Mathematik 111, 116, 245f., 252 Maus 324, 326, 523, 590 Metaautomaten 549 Metcalfe, Robert 315 Microcode 208 Microsoft 299, 324, 457, 469, 487, 502 Microsoft Azure 504 Microsoft Mouse 301 Microsoft Office 300 Microsoft Research 288, 347 Microsoft Tablet PC 301

Middleware 148 Mikrokernel 338 Mikroprozessor 192 Millenium-Bug 110, 329, 331 MILNET 428 Miner, Bob 307 MINIX 315 Minsky, Marvin Lee 522 MMOG 400 MMORPG 371, 387 Modem 443 Modula 274 Modula-2 274 Monolithischer Kernel 338 Moore, Edward F. 548 Moore-Nachbarschaft 548 Moorhuhn 367, 391 Morland, Samuel 71 Mosaic 455 Mozilla 457 Mozilla 씮 Firefox MSX 162 Multics 321 Multiplayer Games 372 Murto, Bill 190 Muster 537, 555, 557 MySQL 316 Mystery House 381

N Napier, John 34 Napiersche Rechenstäbe 34 Napoleon Bonaparte 394f., 514 NASA 423 NCCF.GOV 210 Nelson, Horatio 32 Netscape 316, 456 Netscape Navigator 456 NetWare 312 Neumann, John von 79, 111, 532 Neumann-Automat 532 Neuron 523, 527, 529 Neuronales Netz 520, 530 Neverwinter Nights 387 Newton, Isaac 45, 514 Nexus 454 Night Driver 389

601

Index

Nim 352 Nimrod 352 Novell 312 NSTL 330 Nvidia 226 Nygaard, Kristen 268

O Oates, Ed 307 Oberon 274 Objektorientierte Programmierung 268 OLED 507 Open Source 313 Meilensteine 315 OpenNIC 440 OpenOffice.org 335 Opera 458 Oracle 307, 335, 470 OS/2 298, 328, 343 Oughtred, William 36 OXO 357, 389

P Pac Man 173 Paketvermittlung 424 Panzer General 368, 390 Parallelrechner 203 Parallels Desktop 470 PARC 324 Partridge, Seth 36 Pascal (Programmiersprache) 273, 279, 311 Pascal, Blaise 70 Pascaline 66, 70 PC 189, 203, 315 PC-DOS 299 PDA 582 PDP-1 362 Penrose, Roger 516 Pentium-FDIV-Bug 198 Pentium-Prozessor 199 Perceptron 522, 525 Perl 274, 315 Phoenix 181 Phonograph 41

602

PHP 316 PHP5 492 Pianola 292 Pinball 367 Pinball Construction Set 173 Ping 433 Pirates 175 PL/1 266, 321, 545 Platon 46 Pokémon 390 Pong 169, 359f., 389 Pools of Radiance 387 POSIX-Kalender 331 Postgres 316 PowerPoint 299 Presario 191 Primzahlen 552 Prince of Persia 390 Principia Mathematica 246 PRINT 175, 177 Programmiersprache deklarative 278 imperative 267 prozedurale 267 Prolog 278 Prozessor 117, 169, 193, 239, 332 Python 269, 274, 280, 316

Q Q-Bert 367, 389 Qbits 518 Qemu 470 QNX 338ff., 343 Quadcore-Prozessor 202 Quake 388 Quantencomputer 517 Quantenmechanik 517 Quantentheorie 45 Quantenverschränkung 517

R Räderuhr 58 Radó, Tibor 252 Ratliff, Wayne 304 Raycasting 386f.

Index

Raytracing 387 RDF 458 Rechenhilfe 24 Rechenmaschine Abakus 32 Gebetsschnur 32 Rechenschieber 32 Rosenkranz 30 von Schickard 67 Rechenschieber 32, 35f. Rechenstab 35 Rechnende Räume 560 Registrierkasse 78 REM 177 RFC 424 Richards, Martin 268 Ritchie, Dennis 268, 321 Rogue-like-Spiel 380 Rollenspiel 369 Römische Ziffern 27 Rosenblatt, Frank 521 Rosenkranz 30 Rubik's Cube 394 Ruby 269, 274, 283, 316 Rückkopplung 549 Russell, Bertrand 246 Russell, Stephen 362

S SaaS 503 Safari 458 Sale, Tony 107 SAP 295 Schallplattenspieler 41 Schickard, Wilhelm 35, 67 Schlüsselfernschreibmaschine SZ42 106 Schneider 161 Second Life 369 Semantisches Web 458 SETI 220 Setup 585 Sexagesimalsystem 25 Shareware 313 Shuttleworth, Mark 333, 335, 508 Silverberg, Brad 457 Silverman, Brian 550 SimCity 368, 373, 390

Simula 268f. Simulation 468 EDSAC 357ff. ENIAC 113ff. Sinclair 161, 184 Single Sign-on 502 Single-Sign-on-Authentifizierung 503 Singularity 347 SM124 181 Smalltalk 269, 326f. Smalltalk 80 269 Snake 384, 389 Software 291 Software AG 294 Sokoban 396 Sonnenfinsternis simulieren 87 Sony 161 Spacewar 362, 367, 389 Spaghetticode 169 Spectravideo 161 Spiele 169, 173f., 315, 329, 351, 362, 507 mit vollständiger Information 359 Spielersprache 400 Spieltheorie 112 Spore 409 Sportspiel 371, 400 Sprossenrad 73 Sputnikschock 421 Squeak 269 Staffelwalze 73 Stallman, Richard 314f. Star Division 308 Star Trek 391 Star Wars 391 StarMoney 310 StarOffice 309, 316, 335 Stauffenberg, Claus Schenk Graf von 108 Stellarium 62 Sternenhimmel simulieren 62 Storytelling-RPG 387 Strategiespiel 368 Stroustrup, Bjarne 268f., 276 Summer-/Winter-/Worldgames 173 Sun 203, 307, 309, 316, 335, 470 Superautomat 76 Supercomputer 204, 211, 229 Super-Mario 367, 390 Superposition 518 Systems /360 129

603

Index

T

V

Tandem Computers 191 Tanenbaum, Andrew 315, 338 Tangram 394f. Taschenrechner 78 Tate, George 303 TCP 315, 427f. Teller, Edward 532 Tetris 390 TeX 315 Thompson, Ken 268, 314, 321 Tic-Tac-Toe 357 Tomb Raider 390f. Top-Level-Domain 435 Tortendiagramm 39 Torvalds, Linus 316, 329, 332, 338 TOS 181 Tramiel, Jack 171, 181 Transmission Control Protocol 씮 TCP Tron 320, 384, 389 Tukey, John Wilder 292 TurboPascal 273, 311 Turing Award 326 Turing, Alan Mathison 79, 119, 245f., 255 Turingmaschine 120, 245ff., 250, 252ff., 288f., 559 Turingtest 82, 246, 290 Turingvollständig 253 Türme von Hanoi 257

VAX 148 Vektorrechner 203f. Verdisoft 310 Vierspeziesrechner 67 Virenscanner 478 Virtual PC 469f. VirtualBox 327, 336, 470 Deinstallation 577 Installation 565 Virtualisierung 465, 565 VM 332 Virtueller Maschinen-Monitor 씮 VMM Visual Basic 281 VM VirtualBox 327, 336, 565f., 569f., 577 virtuelle Maschine 579 Xen 332 VMM 470 VMware 469f., 575 VMware vSphere 504 Von Neumann, John 씮 Neumann, John von Von-Neumann-Architektur 112, 292 Von-Neumann-Nachbarschaft 548 Von-Neumann-Regel 535

U U-Bahn von Sendai 46 Ubuntu 333, 466, 508 Ubuntu Enterprice Cloud 504 Ubuntu One 504, 508 Uhr astronomische 58 Ulam, Stanislaw 532 Ultima Underworld I 387 UNIVAC 118 UNIX 268, 314f., 321, 330, 332, 338 Unreal 388, 413 Unscharfe Mengenlehre 46 URL 430

604

W Wasserstoffbombe 532 WATCOM 264 Watson, Andrew 505 Watson, Thomas J. 125, 291, 297 Wayne, Ronald 153 Webarchiv 485 WebOS 485 Webstuhl 292 Weltformel 515 Wii 371, 394 Wiitanen, Martin 362 Williams-Kilburn-Röhre 121 Window Maker 484 Windowmanager 484 Windows 299, 324, 454, 457, 478, 488 VirtualBox installieren 565 Windows 2000 331

Index

Windows 3.1 300 Windows 7 480 Windows 95 386, 455 Windows Calculator 28 Windows NT 3.1 329, 339 Windows Server 2003 331 Windows Vista 331, 465, 480 Windows XP 331 Wing Commander 367, 390 Wireworld 550 Wireworld-Computer 552, 559 Wirth, Niklaus 273 Wirtschaftssimulation 368 Wolfenstein 3D 386, 390 Word 300 Workstation Clons 202 World of Warcraft 370, 372, 390, 392 World Wide Web 씮 WWW WoW 씮 World of Warcraft Wow-Signal 222 Wozniak, Steve 153 WWW 316, 444, 454, 458 WWW Consortium 458

X Xbox 301 Xcerion 488 Xen 332, 469f., 575

Xerox 299, 324 Xerox Alto 158

Z Z1 101, 193 Z2 101 Z3 97 simulieren 103 Z4 98 Zadeh, L. A. 46 Zählen mit Fingern 25 Zahlensystem 24, 27, 47 binäres 27 Hexadezimalsystem 28 Sexagesimalsystem 25 und Alphabet 28 Zehnersystem 24 Zwölfersystem 25 Zahnrad 52 Zauberwürfel 394 Zehnersystem 24 Zehnerübertrag 73 Zeitrechnung 25 Zellulärer Automat 530, 550, 554, 560 Zork 378, 389 Zuse, Konrad 15, 28, 97, 112, 521, 560 Zweispeziesmaschine 67 Zwölfersystem 25 ZX80 184

605

Computergeschichte(n) – nicht nur fur Geeks: Von Antikythera zur Cloud

Computergeschichte(n) – nicht nur fur Geeks: Von Antikythera zur Cloud

Wir sind nicht nur von dieser Welt

Wir sind nicht nur von dieser Welt

Controlling fur Nicht-Controller

Die Terrasse von A'hi-nur

Die Terrasse von A'hi-nur

Die Terrasse von A'hi-nur

Algebra fur Einsteiger: Von der Gleichungsauflosung zur Galois-Theorie

Algebra fur Einsteiger: Von der Gleichungsauflosung zur Galois-Theorie(s)

Algebra fur Einsteiger. Von der Gleichungsauflosung zur Galois-Theorie

Algebra fur Einsteiger. Von der Gleichungsauflosung zur Galois-Theorie

Urheberrechtsfibel - nicht nur fur Piraten: Der Text des deutschen Urheberrechtsgesetzes, erklart und kritisch kommentiert

Zur Chronik von Grieshuus

Zur Chronik von Grieshuus

Nur

Zur Chronik von Grieshuus

Von Tretrad zur Turbine

Von Tretrad zur Turbine

Zur Chronik von Grieshuus

Die Terrasse von A'hi-nur.0

Black cloud, white cloud

Wir sind nicht nur von dieser Welt: Naturwissenschaft, Religion und die Zukunft des Menschen GERMAN

Arduino – Physical Computing fur Bastler, Designer und Geeks

Seelenwanderung und Wiedergeburt. Leben wir nicht nur einmal?

Interventionskultur: Zur Soziologie von Interventionsgesellschaften

Doch von Liebe sprach er nicht

Von der Papyrologie zur Romanistik

Meditation zur Heilung von Beziehungen

Interventionskultur: Zur Soziologie von Interventionsgesellschaften

Ich kann nicht von Dir lassen

Computergeschichte(n) – nicht nur fur Geeks: Von Antikythera zur Cloud