Programmiersprache - Retroware.de

Esotherische 

Programmiersprachen 

Übersicht über die gängisten 

Programmiersprachen 

PDF erstellt mit Hilfe des OpenSource-Werkzeugs „mwlib“. Für weitere Informationen siehe http://code.pediapress.com/ 

PDF generated at: Sun, 28 Mar 2010 21:20:52 UTC

Inhalt 

Artikel 

ActionScript 1 

Algol 60 3 

AppleScript 5 

Assemblersprache 8 

B (Programmiersprache) 14 

BASIC 15 

Borland Delphi 19 

C (Programmiersprache) 19 

C+ + 26 

C- Sharp 33 

COBOL 36 

D (Programmiersprache) 44 

DarkBASIC 46 

FORTRAN 50 

FreeBASIC 56 

Hallo Welt 58 

Java (Programmiersprache) 60 

JavaScript 69 

Lua 82 

Objective- C 84 

Pascal (Programmiersprache) 100 

PEARL 106 

Perl (Programmiersprache) 107 

PHP 123 

Profan (Programmiersprache) 131 

PureBasic 133 

Python (Programmiersprache) 137 

REALbasic 147 

Ruby (Programmiersprache) 148 

Smalltalk (Programmiersprache) 159 

Turbo Pascal 168 

Visual Basic 171 

Esotherische Programmiersprachen 180

Esoterische Programmiersprache 180 

Brainfuck 182 

Brainfuck2D 187 

Referenzen 

Quelle(n) und Bearbeiter des/der Artikel(s) 193 

Quelle(n), Lizenz(en) und Autor(en) des Bildes 197 

Artikellizenzen 

Lizenz 198


ActionScript 

ActionScript 

Designer: Gary Grossman 

Entwickler: Adobe Systems 

Aktuelle Version: 3.0 (27. Juni 2006) 

Typisierung: stark, statisch 

Einflüsse: JavaScript, Java 

Betriebssystem: plattformunabhängig 

www.adobe.de [1] 

ActionScript (kurz: AS) ist eine Programmiersprache des US-amerikanischen Softwareunternehmens Adobe 

Systems auf Basis des ECMAScript-Standards (ECMA-262) und kann in einer Reihe von Adobe-Produkten 

eingesetzt werden, so zum Beispiel Adobe Flash, Flex und Air. Somit kann man von einfachen Flash-Animationen 

bis hin zu komplexen Webanwendungen, sogenannten Rich Internet Application, aber auch neuerdings 

Desktop-Anwendungen (Adobe Air) erstellen. Die Sprache wurde ursprünglich von Macromedia entwickelt, das im 

Dezember 2005 von Adobe Systems übernommen wurde. 

Während Flash selbst anfangs zur Darstellung von Medieninhalten, wie Animationen und Filmen, diente, kam mit 

ActionScript die Möglichkeit interaktiver Anwendungen und Datenverarbeitung hinzu. 

Funktion 

Die Sprache wird in der integrierten Entwicklungsumgebung (IDE) Adobe Flash entwickelt, die auch das Debuggen 

unterstützt. Anwendungsseitig wird sie vom Flash-Player, eigenständig oder als Browser-Plugin beim Abspielen 

eines Flash-Scripts interpretiert. Laut einer Statistik von Macromedia verfügen über 97 % [2] aller Browser über ein 

Flash-Player-Plugin. 

Mittlerweile gibt es auch eine Reihe kommerzieller sowie quelloffener Werkzeuge von anderen Herstellern, die 

ebenfalls Flash-Filme erzeugen können; Beispiele aus dem Open-Source-Bereich sind Ming und OpenLaszlo. 

ActionScripts arbeiten stets ereignisorientiert. Sie werden also nur nach einem eingetretenen Ereignis ausgeführt. 

Dazu gehören etwa: 

• Schlüsselbilder – sobald der Player ein bestimmtes Schlüsselbild abspielt 

• Schaltflächensymbole – der Nutzer fährt mit der Maus über eine Schaltfläche oder klickt diese an 

• MovieClip-Symbole – eingebettete MovieClips lösen selbst Ereignisse aus 

• Intervallimpulse – Gestartete Intervalle (mit IRQs zu vergleichen) lösen den Aufruf aus


ActionScript 3.0 

ActionScript 3.0 stellt eine große, nichtkompatible Erweiterung der Sprache dar, die auf Entwürfen zu ECMAScript 

4 beruht. U.a. enthält AS3 Typdeklarationen und -überprüfungen zur Compile-Zeit und klassenbasierte 

Objektorientierung. Gerade diese großen Änderungen führten zum Abbruch der Entwicklung von ECMAScript 4.0, 

so dass ActionScript jetzt ein isolierter Vertreter dieses Sprachentwurfs ist. 

Zur Ausführung des kompilierten Zwischencodes wird eine völlig neugeschriebene virtuelle Maschine benutzt. 

Literatur 

• Norbert Busche: Das Einsteigerseminar Macromedia Flash-MX-2004-Programmierung mit ActionScript 2.0. 

Vmi Buch, 2004, ISBN 3-8266-7277-1. 

• Tobias Hauser: Einstieg in ActionScript. Galileo Press, 2006, ISBN 3-89842-774-9. 

• Caroline und Matthias Kannengiesser: ActionScript Praxisbuch – Studienausgabe. Franzis, 2005, ISBN 

3-7723-6645-7. 

• Colin Moock: ActionScript für Flash MX – Die Referenz. O'Reilly Verlag, 2003, ISBN 3-89721-355-9. 

• Colin Moock: ActionScript für Flash MX – Das Handbuch. O'Reilly Verlag, 2003, ISBN 3-89721-354-0. 

• Colin Moock: Essential ActionScript 3. O'Reilly Verlag, 2007, ISBN 0-596-52694-6. 

Siehe auch 

• Adobe Flash 

• Adobe Flex 

• haXe (Programmiersprache) – alternative Sprache zum Einsatz in SWF-Dateien und Webanwendungen 

• Flash Development Tools – proprietäres Eclipse-Plugin zur Entwicklung von ActionScript 

Weblinks 

• ActionScript-Programmierstil-Standards [3] (PDF, englisch) 

• ActionScript 2.0 Referenzhandbuch (von Macromedia) [4] 

• ActionScript 3.0 Referenzhandbuch (von Adobe) [5] 

• ECMAScript-Sprachspezifikation [6] (englisch) 

• Einführung Actionscript 3.0 [7] (deutsch) 

• Tutorials (von Macromedia) [8] (englisch) 

• as3compile [9] Freier Compiler für ActionScript 3.0 

Referenzen 

[1] http:/ / www. adobe. de/ 

[2] Verbreitungsstatistik (http:/ / www. adobe. com/ products/ player_census/ flashplayer/ version_penetration. html) 

[3] http:/ / www. macromedia. com/ devnet/ mx/ flash/ whitepapers/ actionscript_standards. pdf 

[4] http:/ / livedocs. macromedia. com/ flash/ 8_de/ main/ wwhelp/ wwhimpl/ js/ html/ wwhelp. htm?href=Part4_ASLR2. html 

[5] http:/ / livedocs. adobe. com/ flash/ 9. 0_de/ ActionScriptLangRefV3/ 

[6] http:/ / www. ecma-international. org/ publications/ standards/ Ecma-262. htm 

[7] http:/ / www. kurztutorial. info/ actionscript3/ inhalt. htm 

[8] http:/ / www. actionscript. org 

[9] http:/ / www. swftools. org

Algol 60 3 

Algol 60 

Die Programmiersprache Algol 60 wurde von 1958–1963 unter der Führung der Association for Computing 

Machinery (ACM) und der Gesellschaft für Angewandte Mathematik und Mechanik (GAMM), später dann der 

International Federation for Information Processing (IFIP), entwickelt. Beteiligt waren unter anderem John Backus, 

Friedrich Ludwig Bauer, John McCarthy, Peter Naur, Alan J. Perlis, Heinz Rutishauser und Klaus Samelson. Der 

Name Algol ist eine Kurzform für Algorithmic Language, 60 steht für das Jahr der »Fastfertigstellung« (ein 

Diskussionsentwurf wurde als International Algorithmic Language (IAL) oder Algol 58 bekannt; die endgültige 

Fassung (als »Revised Report« tituliert) stammt aus dem Jahre 1963). 

Der Sprachentwurf 

Algol 60 war als international entwickelte, von kommerziellen Interessen unabhängige, portable, prozedurale 

Programmiersprache in erster Linie für wissenschaftliche, das hieß damals numerische, Zwecke gedacht. Es gab aber 

auch wichtige nichtnumerische Anwendungen, weil ihre Einfachheit und für damalige Verhältnisse weitgehende 

Freiheit von Restriktionen sie angenehm zu benutzen machte. 

So wurde das Betriebssystem der Burroughs B5000 Rechner in einer ALGOL-Version (ESPOL) 

programmiert; ein anderes Beispiel ist ein bibliothekarisches Katalogsystem für die Telefunken TR 4. Vgl. 

auch die Sprache JOVIAL, von ALGOL 58 abgeleitet, die jahrzehntelang zur Programmierung von 

Prozessrechnern in der Luft- und Raumfahrt (Avionik) diente. 

Algol 60 war ein Meilenstein in der Geschichte der Programmiersprachen: 

• Mit ihr begann die saubere Definition von Spracheigenschaften unabhängig von (und vor) jeder Implementierung 

(anders als dies noch bei LISP war [1] ). 

• Der Algol 60 Report führte die formale Definition der Syntax mit Hilfe der Backus-Naur-Form ein, die bald 

allgemein üblich wurde. 

• ALGOL zeigte den Wert eines klaren und einfachen Sprachkerns auf, eine Erfahrung, die bald Peter Landin zu 

seinem Sprachentwurf ISWIM inspirieren und so die meisten nach ALGOL entwickelten Programmiersprachen 

beeinflussen sollte. 

• ALGOL schrieb – gegen den Trend der Zeit – Laufzeitprüfungen vor, eine Entscheidung, die erst langsam 

gewürdigt und nachgeahmt wurde. 

• Auch die Unterscheidung zwischen der Sprache an sich und ihrer technischen (Eingabe-) Darstellung (die auf 

vorhandenen Geräte Rücksicht nehmen musste) fand Beifall, aber nur wenige Nachfolger. [2] 

Als (unerwartet) großes Problem erwies sich, dass die Ein-/Ausgabe nicht geregelt worden war, so dass deren 

Implementierungen stark zwischen den Compilern variieren. Beispielsweise wird ein Text einmal mit dem 

OUTSTRING- und einmal mit dem WRITETEXT-Befehl (beispielsweise bei der Electrologica X1) ausgegeben. 

Eigenschaften 

Die Methode der sequentiellen Formelübersetzung von Bauer und Samelson ermöglichte es, auf viele Restriktionen 

zu verzichten, wie sie etwa FORTRAN kannte. Die darin enthaltene Idee des Stapelspeichers ermöglichte dann auch 

rekursive Prozeduren (Dijkstra). 

Vom λ-Kalkül inspiriert war die Möglichkeit innerer Prozedurdefinitionen (»Blockstruktur«). ‚begin‘-Blöcke 

(anonyme Prozeduren) wurden vor allem dazu benutzt, Felder mit variablen Grenzen im Kellerspeicher anzulegen. 

Sichtbarkeit und Gültigkeitsbereich der Variablen waren dabei korrekt lexikalisch definiert. Vorgesehen waren auch 

‚own‘-Variablen, deren Lebensdauer der Programmlauf sein sollte (vgl. ‚static‘ in C); gerade dies wurde aber häufig 

nicht implementiert.

Algol 60 4 

Ebenfalls vom λ-Kalkül waren die Parameterübergabe-Modi genommen: 

• Wertparameter (Schlüsselwort ‚value‘) wurden vor dem Aufruf ausgewertet (Strikte Auswertung – »erst 

Auswerten, dann Einsetzen«). 

• Für Namensparameter, default, war die Semantik einer textuellen Einsetzung vorgeschrieben (Nichtstrikte (lazy) 

Auswertung – »erst Einsetzen, dann Auswerten«). Dies führte im Zusammenhang mit Speichervariablen zu 

gewissen Schwierigkeiten, erlaubte im Prinzip aber eine elegante Formulierung von Integralen und ähnlichen 

Aufgaben: 

integriere (alpha*x*x, x, a, b) 

(Jensen's device). Zur Implementierung verwandte man thunks, Closures von anonymen Funktionen (und 

benannt »nach dem Geräusch, das sie auf der 7090 machten«). 

Algol führte mit LISP das Prinzip der Formatfreiheit in Programmiersprachen ein. Dabei hat ein Schlüsselwort 

immer dieselbe Bedeutung, unabhängig von der Position im Programm. Außerdem ist der Beginn einer neuen Zeile 

dem Leerzeichen gleichgestellt. In den damals vorherrschenden Sprachen FORTRAN und COBOL war die 

Positionierung der Anweisungen auf den Lochkarten dagegen entscheidend – ein Schlüsselwort konnte je nach 

Position eine andere Bedeutung haben. Auch die Zeileneinteilung war bei diesen Sprachen nicht frei. 

Beispiel 

Das folgende (vollständige) Algol-60-Programm gibt "HALLO, WELT" auf dem Ausgabekanal 2 aus: 

'COMMENT' HALLO, WELT PROGRAMM IN ALGOL 60; 

'BEGIN' 

'END' 

OUTSTRING(2,'('HALLO, WELT')'); 

Wirkungen/Bedeutung/Nachfolger 

ALGOL war ein Fortschritt gegenüber den meisten seiner Nachfolger. -- C. A. R. Hoare. 

In der Praxis fand Algol weniger Anwendung als FORTRAN oder COBOL; das minderte aber nicht seinen 

langfristigen Einfluss (s. o.). Lange Zeit war Algol 60 im akademischen Bereich vorbildlich. 

Der wichtigste Nachfolger war Simula 67. 

Nach John C. Reynolds folgten die meisten Sprachen nicht Algol 60, sondern ISWIM; er selbst stellte mit Forsythe 

eine Fortentwicklung in der Algol-Tradition vor. [3] 

Algol 68 war dem Namen zum Trotz ein völliger Neuentwurf, der ein geteiltes Echo fand. Niklaus Wirth entwickelte 

alternativ Algol W, woraus in der Weiterentwicklung Pascal werden sollte.

Algol 60 5 

Siehe auch 

• Liste der Programmiersprachen 

• Namensparameter 

Literatur 

• H.T. de Beer: The History of the ALGOL Effort. [4] 2006. – vi, 97 pp. (M.Sc. thesis, TU Eindhoven) 

• Heinz Rutishauser: Description of Algol 60. – Berlin, 1967. (Handbook for automatic computation; 1,a) 

• Albert A. Grau; U. Hill; Hans Langmaack: Translation of Algol 60. – Berlin, 1967. (Handbook for automatic 

computation; 1,b) 

Weblinks 

• http:/ / www. gnu. org/ software/ marst/ marst. html - MARST: an Algol-to-C translator 

Referenzen 

[1] Erst mit Scheme wurde das anders; später wurde auch in Common-Lisp der Geburtsfehler des dynamischen Geltungsbereichs (dynamic 

scope) korrigiert. 

[2] Etwa Fortress. Vgl. ISWIM und Pepper/Hofstedt, Funktionale Programmierung (2006), »Jenseits von ASCII« (S. 4) 

[3] http:/ / citeseer. ist. psu. edu/ reynolds96design. html 

[4] http:/ / heerdebeer. org/ ALGOL/ The_History_of_ALGOL. pdf 

AppleScript 

Entwickler: Apple 

AppleScript 

Aktuelle Version: 2.1.1 (9. November 2009) 

Betriebssystem: Mac OS, Mac OS X 

Kategorie: Programmiersprache, 

Skriptsprache 

Deutschsprachig: nein 

developer.apple.com/applescript [1] 

AppleScript ist eine Skriptsprache von Apple, die ein Bestandteil von Mac OS ist. AppleScript dient dazu, Mac 

OS-Programme zu automatisieren, zu erweitern und innerhalb eines Rechnernetzes fernzusteuern. 

Die erste Version von AppleScript basierte auf dem HyperCard-Projekt. HyperCard beinhaltete mit der 

Skriptsprache HyperTalk eine auf der englischen Sprache basierende Skriptsprache. Dadurch sind 

AppleScript-Programme auch für Personen, die nicht programmieren können, relativ einfach zu verstehen.

AppleScript 6 

Sprachsyntax 

Apple hat sich traditionell das Ziel gesetzt, einfach zu bedienende Computer und Software zu verbreiten. In dieser 

Philosophie hat Apple AppleScript so entwickelt, dass es an die natürliche englische Sprache angepasst ist. 

Der Aufruf einer objektorientierten Methode geschieht unter AppleScript wie folgt: 

character 1 of item 2 of {"one", "two", "three"} 

Auf Deutsch würde es so heißen: 

Zeichen 1 des Elementes 2 von {"one", "two", "three"} 

In „gewöhnlichen“ Sprachen wie Java dagegen wie folgt: 

String[] x = {"one","two","three"}; 

char y = x[1].charAt(0); 

Es ist hier ersichtlich, dass Apple sich bemüht, AppleScript auf der Basis der englischen Sprache zu setzen und nicht 

dem Trend der traditionellen Programmiersprachen zu folgen. 

Applikationsübergreifende Kommunikation 

AppleScript wird primär dazu benutzt, andere Programme von einem Programm aus „fernzubedienen“. Mac OS 

bietet AppleEvents an, ein applikationsübergreifendes Kommunikationsprotokoll, mit dem es möglich ist, 

Nachrichten von einer Applikation zu einer anderen Applikation zu senden, so dass diese sich wie gewünscht 

verhält. 

So kann man zum Beispiel aus einem Skript heraus eine Applikation anweisen, ein bestimmtes Dokument zu öffnen. 

Mit dem Wort „tell“ wird eine solche Nachricht z. B. an Word geschickt: 

tell application "Microsoft Word" 

open file "Diplomarbeit" of folder "Dokumente" of disk "Studium" 

end tell 

Auf Deutsch: 

Sage Anwendung "Microsoft Word" 

öffne Dokument "Diplomarbeit" aus dem Ordner "Dokumente" der 

Festplatte "Studium" 

Ende der Nachricht 

AppleScript zur Automatisierung 

AppleScript ist nicht nur für applikationsübergreifende Aufgaben entworfen. Es kann auch eingesetzt werden, zum 

Beispiel um häufig wiederkehrende Aufgaben zu automatisieren oder Berechnungen durchzuführen. Ein Beispiel: 

set pix to 72 

set answer to text returned of (display dialog "Enter in the number of 

inches" default answer "1") 

display dialog answer & "in = " & (answer * pix) & "px" 

Auf Deutsch würde es so heißen: 

setze pixel auf 72 

setze antwort auf zurückgegebener Text von (zeige Dialog "Gib die Länge 

in Zoll ein" Standardantwort "1")

AppleScript 7 

zeige Dialog antwort & "in = " & (antwort * pixel) & 

"pixel" 

Es zeigt ein Dialogfeld und fragt nach der Länge in Inches. Es wird dann berechnet, wie viele Pixel es auf dieser 

Länge geben wird. Ein zweites Dialogfeld zeigt dann das Resultat. 

AppleScript-Dialekte 

Apple ließ für eine kurze Zeit das AppleScript sogar so erweitern, dass man die Skripte nicht zwingend auf Englisch 

schreiben musste. Man sollte die Skripts in der eigenen Muttersprache schreiben können. So wurde die 

Skriptterminologie auf Französisch, Japanisch und Italienisch übersetzt und Mac OS konnte diese von einem Dialekt 

in einen anderen Dialekt übersetzen. Dies funktionierte zwar, doch die Entwickler von Macintosh-Software 

(außerhalb von Apple) unterstützten die Mehrsprachigkeit von AppleScript wegen des großen Aufwandes nur 

unzureichend. Da auch der Support umständlich war, wurde diese Idee in Mac OS 8.5 und höher nicht mehr weiter 

verfolgt. 

Literatur 

• Detlef Schulz: AppleScript - der automatische Mac / [Detlef Schulz]. SmartBooks, Pfäffikon, SZ 2009, ISBN 

978-3-908497-78-3, S. 844. 

Weblinks 

• http:/ / developer. apple. com/ referencelibrary/ ScriptingAutomation/ idxAppleScript-date. html 

• http:/ / www. macosxautomation. com/ applescript/ 

• http:/ / www. applescriptsourcebook. com/ 

• AppleScript für absolute Starter [2] 

Referenzen 

[1] http:/ / developer. apple. com/ applescript/ 

[2] http:/ / www. fischer-bayern. de/ applescript/ html/ ebook. html


Assemblersprache 

Eine Assemblersprache ist eine spezielle Programmiersprache, welche die Maschinensprache einer spezifischen 

Prozessorarchitektur in einer für den Menschen lesbaren Form repräsentiert. Jede Computerarchitektur hat folglich 

ihre eigene Assemblersprache. 

Übersicht 

Ein Programm in Assemblersprache wird auch als Assemblercode bezeichnet. Es wird durch einen speziellen 

Compiler, ebenfalls Assembler genannt, in direkt ausführbare Maschinensprache (auch Maschinencode) 

umgewandelt. Die umgekehrte Umsetzung von Maschinencode in menschenlesbaren Assemblercode wird 

Disassemblierung genannt. Allerdings lassen sich dabei beiläufige Informationen wie Bezeichner und Kommentare 

nicht wiederherstellen, da diese bereits bei der Compilierung unwiederbringlich verloren gingen, was ein Verstehen 

des Programms erschwert. 

Programme in Assemblersprache zeichnen sich dadurch aus, dass man die komplette Bandbreite des Computers 

ausnutzen und Hardwarechips direkt programmieren kann. Weil Assemblerprogramme faktisch auf 

Maschinencode-Ebene arbeiten, sind sie oftmals erheblich kleiner und schneller als Programme, die einen ähnlichen 

Grad an Komplexität aufweisen, aber eine Hochsprache als Basis haben. Der Compiler einer höheren 

Programmiersprache erzeugt meistens mehr Code, weil er stark generalisiert geschrieben werden muss. Die 

zwingende Nutzung von Assemblersprache ist heutzutage selten erforderlich, außer wenn Programme bzw. Teile 

davon sehr zeitkritisch sind (beispielsweise bei der Programmierung von Gerätetreibern für Grafikkarten) oder nur 

einen sehr geringen Speicherplatzbedarf aufweisen dürfen (z. B. in eingebetteten Systemen) oder einfach noch keine 

Hochsprach-Bibliotheken existieren, z. B. bei völlig neuer Technik. Prinzipiell wird immer mehr an maschinennaher 

Programmierung – die Domäne von Assembler – heute durch höhere Programmiersprachen abgedeckt. Auch steht 

der Möglichkeit der Erstellung effizienter Programme die erschwerte Wartbarkeit von Assemblerprogrammen 

gegenüber. Weitere Nachteile von Assemblercode sind u. a. höhere Fehleranfälligkeit (durch erhöhte Komplexität), 

damit verbunden extrem großer Programmieraufwand bei umfangreichen Projekten und die (praktische) 

Unmöglichkeit des Portierens auf eine andere Hardware. 

Unter dem Aspekt der Geschwindigkeitsoptimierung kann der Einsatz von Assemblercode auch bei verfügbaren 

hochoptimierten Compilern noch seine Berechtigung haben, muss aber differenziert betrachtet und für die 

spezifische Anwendung abgewogen werden. Bei komplexer Technik wie Intel Itanium und verschiedenen DSPs 

kann ein Compiler u. U. durchaus besseren Code erzeugen als ein durchschnittlicher Assemblerprogrammierer, da 

das Ablaufverhalten solcher Architekturen mit komplexen mehrstufigen intelligenten Optimierungen (z. B.: 

Out-of-Order Excecution, Pipeline-Stalls, …) hochgradig nichtlinear ist. Die Geschwindigkeitsoptimierung wird 

immer komplexer, da zahlreiche Nebenbedingungen eingehalten werden müssen, ein gleichermaßen wachsendes 

Problem für die durchaus immer besser werdenden Compiler der Hochsprachen als auch für Programmierer der 

Assemblersprache. Für einen optimalen Code wird immer mehr Kontextwissen benötigt (z. B.: Cachenutzung, 

räumliche und zeitliche Lokalität der Speicherzugriffe), welches der Assembler-Programmierer teilweise (im 

Gegensatz zum Compiler) durch Laufzeitprofiling des ausgeführten Codes in seinem angestrebten Anwendungsfeld 

gewinnen kann. Ein Beispiel hierfür ist der SSE-Befehl MOVNTQ, welcher wegen des fehlenden Kontextwissens 

von Compilern kaum optimal eingesetzt werden kann.


Beschreibung 

Programmbefehle in Maschinensprache - Instruktionen - sind einfache Bitmuster, die sich aus den Opcodes und den 

zugehörigen Daten bilden. Da die Zahlenwerte der Opcodes schwieriger zu merken sind, verwendet eine 

Assemblersprache besser merkbare Kürzel, so genannte mnemonische Symbole (kurz Mnemonics). 

Beispiel: 

Der folgende Befehl in der Maschinensprache von x86-Prozessoren 

10110000 01100001 

entspricht dem Assemblerbefehl 

movb $0x61, %al ; AT&T-Syntax (Zeichen nach einem „;“ gelten als 

Kommentare) 

bzw. 

mov al, 61h ; Intel-Syntax 

und bedeutet, dass der hexadezimale Wert 61 (97 dezimal) ins Register ‚al‘ geladen werden soll (al: dabei steht das 

‚a‘ für das Register, und das ‚l‘ für low, was praktisch dem ersten Teil des Registers entspricht). Der zweite Teil des 

Registers wird mit einem ‚h‘ ausgezeichnet, das ‚h‘ steht für High (Also: ‚ah‘). Soll das ganze Register (je nach 

Speicherbedarfs des Typs, der gespeichert werden soll) angesprochen werden, wird ‚l‘ bzw. ‚h‘ durch ein ‚x‘ ersetzt: 

‚ax‘. Mit Computerhilfe kann man das eine in das andere weitgehend eins zu eins übersetzen. Jedoch werden 

Adressumformungen vorgenommen, so dass man symbolische Adressen benutzen kann. Im Allgemeinen haben die 

Assembler neben den eigentlichen Codes auch Steueranweisungen, die die Programmierung bequemer machen, zum 

Beispiel zur Definition eines Basisregisters. 

Häufig werden komplexere Assemblersprachen (Makroassembler) verwendet, um die Programmierarbeit zu 

erleichtern. Makros sind dabei Bruchstücke von Assemblercode, der vor dem eigentlichen Assemblieren automatisch 

an Stelle der Makroaufrufe eingefügt wird. Dabei können einfache Parameterersetzungen vorgenommen werden. Die 

Disassemblierung von derart generiertem Code ergibt allerdings den reinen Assemblercode ohne die beim 

Übersetzen expandierten Makros. 

Beispielprogramme 

Hello World in Assemblersprache (MASM für MS-DOS) 

DATA SEGMENT ;- Beginn des Datensegments 

Meldung db "Hello World" ;- Die Zeichenkette "Hello World" 

db "$" ;- Endzeichen der Zeichenkette 

DATA ENDS ;- Ende des Datensegment 

CODE SEGMENT ;- Beginn des Codesegements 

ASSUME CS:CODE,DS:DATA ;- Dem Assembler die Segmente mitteilen 

Anfang: ;- Label für den Anfang des Programms 

mov ax, DATA ;- das Daten... 

mov ds, ax ; ...segment festlegen 

mov dx, offset Meldung ;- den Text in das auf DS bezogene 

Datenregister laden 

mov ah, 09h ;- Die Unterfunktion 9 des 

Betriebssysteminterrupts 21h auswählen 

int 21h ;- den Betriebssysteminterrupt 21h (hier


erfolgt Ausgabe des Texts) aufrufen 

mov ax, 4C00h ;- Die Unterfunktion 4Ch 

(Programmbeendigung) des Betriebssysteminterrupts 21h festlegen 

int 21h ;- diesen Befehl wiederum ausführen 

CODE ENDS ;- Ende des Codesegments 

END Anfang ;- dem Assembler das Ende des Labels Anfang 

mitteilen 

Hello World in Assemblersprache (NASM für MS-DOS) 

ORG 100h ; Startoffset auf 100h setzen (Startpunkt 

für COM-Programme) 

mov ax, cs ; Wert des Codesegmentregisters in Register 

ax übertragen 

mov ds, ax ; Datensegment auf Wert von ax setzen 

mov ah, 09h ; DOS-Funktion zum Schreiben von Text 

mov dx, Meldung ; Adresse des Textes 

int 21h ; DOS-Funktion ausführen 

mov ax, 4C00h ; DOS-Funktion um das Programm zu beenden 

int 21h 

Meldung: db "Hello World" ; Unser Text 

db "$" ; Markiert das Ende der Zeichenkette 

Hello World in Assemblersprache (MIPS-Architektur) 

.data 

out: .asciiz "Hallo Welt" # Die Zeichenkette zum Ausgeben 

(als Label) 

.text 

main: li $v0, 4 # Befehl 4 ('print_string') in Register 

schreiben 

la $a0, out # Argument für den Systemaufruf in das 

Argumentregister schreiben 

(Ausgabe) 

syscall # Ausführung der Systemfunktion 

li $v0, 10 # Befehl 10 ('exit') in Register schreiben 

syscall # Ausführung der Systemfunktion 

(Programmende)


Hello World in Assemblersprache (Jasmin) 

; HelloWorld.j 

.bytecode 50.0 

.source HelloWorld.java 

.class public HelloWorld 

.super java/lang/Object 

.method public ()V 

.limit stack 1 

.limit locals 1 

aload_0 

invokespecial java/lang/Object/()V 

return 

.end method 

.method public static main([Ljava/lang/String;)V 

.limit stack 2 

.limit locals 1 

getstatic java/lang/System/out Ljava/io/PrintStream; 

ldc "Hello World!" 

invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V 

return 

.end method 

Der zum Assembler-Quelltext HelloWorld.j zugehörige Java-Quelltext HelloWorld.java lautet: 

/* HelloWorld.java */ 

public class HelloWorld { 

} 

public static void main(String[] args) { 

} 

System.out.println("Hello World!"); 

Verschiedene Assemblersprachen 

Jede Computerarchitektur hat ihre eigene Maschinensprache und damit Assemblersprache. Vereinzelt existieren 

sogar mehrere verschiedene Assemblersprachen (und zugehörige Assembler) für die gleiche Prozessorarchitektur. 

Die Beispiele oben sind für x86-Prozessoren. Die Sprachen unterscheiden sich in Anzahl und Typ der Operationen. 

Jedoch haben alle Architekturen die folgenden grundlegenden Operationen: 

• Daten lesen und schreiben innerhalb des Zentralspeichers sowie Datenaustausch mit Registern, 

• einfache arithmetische Operationen (mit Gleitkommaprozessoren auch komplexe), 

• einfache logische Operationen, 

• einfache Kontrolle des Programmflusses. 

Bestimmte Rechnerarchitekturen haben oft auch komplexere Befehle wie z. B.: 

• einen großen Speicherblock im Hauptspeicher verschieben;


• höhere Arithmetik wie Sinus-, Kosinus- und Wurzelberechnung (entweder über spezielle Zusatzprozessoren 

realisiert oder über Softwareroutinen); 

• eine einfache Operation (z. B. Addition) auf einen Vektor von Werten anwenden; 

• massive, direkte Parallelprogrammierbarkeit des Prozessors, etwa bei digitalen Signalprozessoren; 

• Unterbrechungssteuerungen, die besonders für Prozessrechner benötigt werden; 

• Aufrufe von Ein- bzw. Ausgabegeräten; 

• Synchronisation mit anderen Prozessoren für SMP-Systeme. 

Geschichte 

Früher wurden Betriebssysteme in einer Assemblersprache geschrieben. Heute werden jedoch Hochsprachen 

bevorzugt, in den meisten Fällen C. Allerdings müssen häufig kleine Assemblerroutinen hardwarenahe Aufgaben in 

Betriebssystemen übernehmen. Dazu gehört zum Beispiel das Speichern von Registern in Schedulern, oder bei der 

x86-Architektur der Teil des Boot-Loaders, der innerhalb des 512 Byte großen Master Boot Records untergebracht 

sein muss. Auch Teile von Gerätetreibern werden in Assemblersprache geschrieben, falls aus den Hochsprachen kein 

effizienter Hardware-Zugriff möglich ist. Manche Hochsprachencompiler erlauben es, direkt im eigentlichen 

Quellcode Assemblercode, sogenannte Inline-Assembler-Routinen, einzubetten. 

Bis ca. 1990 wurden die meisten Computerspiele in Assemblersprachen programmiert, da nur so auf Heimcomputern 

und den damaligen Spielkonsolen eine akzeptable Spielgeschwindigkeit und eine den kleinen Speicher dieser 

Systeme nicht sprengende Programmgröße zu erzielen war. Noch heute gehören Computerspiele zu den 

Programmen, bei denen am ehesten kleinere assemblersprachliche Programmteile zum Einsatz kommen, um so 

Prozessorerweiterungen wie SSE zu nutzen. 

Bei vielen Anwendungen für Geräte, die von Mikrocontrollern gesteuert sind, war früher oft eine Programmierung in 

Assembler notwendig, um die knappen Ressourcen dieser Mikrocontroller optimal auszunutzen. Dies gilt heute 

praktisch nur noch, wenn wegen Massenproduktion möglichst günstige und damit minimale Mikrocontroller 

verwendet werden sollen und das Programm nicht zu komplex ist. Um Code für solche Mikrocontroller zu erzeugen, 

werden Cross-Assembler bei der Entwicklung eingesetzt. Moderne C-Compiler haben aber auch in diesem Bereich 

die Assembler abgelöst. Nicht zuletzt aufgrund größerer Programmspeicher bei gleichen Kosten für die Chips fallen 

die Vorteile von Hochsprachen gegenüber den teils verschwindend geringen Vorteilen der Assemblersprache immer 

mehr ins Gewicht. 

Vorteile 

Von erfahrenen Programmierern geschriebene Assemblerprogramme sind fast immer deutlich schneller als die 

Produkte der Hochsprachencompiler. [1] [2] Beispielsweise sind im Bereich des wissenschaftlichen Rechnens die 

[3] [4] 

schnellsten Varianten mathematischer Bibliotheken wie BLAS weiterhin die mit Assembler-Code optimierten. 

Auch lassen sich gewisse sehr systemnahe Operationen bzw. Operationen unter Umgehung des Betriebssystems 

(z.B. direktes Schreiben in den Bildschirmspeicher) immer noch nicht in allen Hochsprachen ausführen. Der Nutzen 

von Assembler liegt auch in dem Verstehen, wie ein System arbeitet und funktioniert, um damit in Hochsprachen 

umständliche Konstrukte zu vermeiden. Auch heute noch wird an vielen Hochschulen Assembler gelehrt. Es geht 

darum, ein Gefühl für den Rechner und seine Arbeitsweise zu bekommen. 

Es gibt Fälle, in denen diskrete Berechnungen einfacher und effizienter direkt in Assembler geschrieben werden. Die 

meisten Hochsprachencompiler übersetzen zuerst in Assemblercode oder können diesen optional ausgeben, so dass 

man Details genauer betrachten und gewisse Stellen von Hand optimieren kann.


Nachteile 

Da Assemblerprogramme sehr hardwarenah geschrieben werden, weil die unterschiedlichen Spezifikationen der 

einzelnen Prozessorentypen individuell verschiedene Maschinencode-Befehlssätze erfordern, kann ein 

Assemblerprogramm nicht auf ein anderes Computersystem übertragen werden ohne die Programmstruktur 

anzupassen. Das erfordert häufig ein komplettes Neuschreiben des Programmtextes. Im Gegensatz dazu muss bei 

Hochsprachen nur der Compiler individuell auf ein anderes Betriebssystem angepasst (neu geschrieben) werden, da 

dieser im Regelfall den Programmcode in eine für das Betriebssystem verwertbare Form umwandelt. Das 

Betriebssystem seinerseits übernimmt die Vermittlung zur Hardwareebene. 

Das Programmieren in Assembler ist oft mit einer großen Anzahl an Einzelbefehlen verbunden, da häufig kleinste 

Informationseinheiten in einzelnen Speicherzellen manipuliert werden müssen. Würde man den Funktionsumfang 

eines einzelnen Hochsprachenbefehls in einer Assemblersprache realisieren wollen, entstünde dabei ein komplettes 

Programm. 

Literatur 

• Gerhard Niemeyer: Einführung in das Programmieren in ASSEMBLER, de Gruyter, 1989, ISBN 3-11-012174-3 

• Joachim Rohde: Assembler Ge-Packt, Mitp-Verlag, 2000, ISBN 978-3-8266-1756-0 

• Joachim Rohde, Marcus Roming: Assembler: Grundlagen der Programmierung, Mitp-Verlag, 2006, ISBN 

978-3-8266-1469-9 

• Jeff Duntemann: Assembly Language Step-by-Step, Wiley, 2000. ISBN 0-471-37523-3 

• Paul Carter: PC Assembly Language, kostenloses E-Book, 2001, auf der Website [5] erhältlich 

• Robert Britton: MIPS Assembly Language Programming, Prentice Hall, 2003. ISBN 0-13-142044-5 

• Randall Hyde: The Art of Assembly Language, No Starch Press, 2003. ISBN 1-886411-97-2 als PDF oder HTML 

[6] 

• Steve McConnell [7]: Code Complete, Microsoft Press, 1993, ISBN 1-55615-484-4 

Weblinks 

• Randall Hydes 'The Art of Assembly Language' als HTML und PDF version [6] 

• Assembler X86 Befehlslisten/OpCode und Beschreibungen [8] 

• Assembler-Programmierung unter Linux [9] 

• i8086.de 8086/88 Assembler Befehlsreferenz [10] 

• Pentium Befehlssatz und Takttabelle [11] 

Referenzen 

[1] Bit-field-badness (englisch) (http:/ / hardwarebug. org/ 2010/ 01/ 30/ bit-field-badness/ ). hardwarebug.org (30. Januar 2010). Abgerufen am 

4. März 2010. 

[2] GCC makes a mess (englisch) (http:/ / hardwarebug. org/ 2009/ 05/ 13/ gcc-makes-a-mess/ ). hardwarebug.org (13. Mai 2009). Abgerufen am 

4. März 2010. 

[3] Writing the Fastest Code, by Hand, for Fun: A Human Computer Keeps Speeding Up Chips (englisch) (http:/ / www. nytimes. com/ 2005/ 11/ 

28/ technology/ 28super. html?_r=1). New York Times, John Markoff (28. November 2005). Abgerufen am 4. März 2010. 

[4] BLAS Benchmark-August2008 (http:/ / eigen. tuxfamily. org/ index. php?title=Benchmark-August2008). eigen.tuxfamily.org (1. August 

2008). Abgerufen am 4. März 2010. 

[5] http:/ / drpaulcarter. com/ pcasm/ 

[6] http:/ / webster. cs. ucr. edu/ AoA/ index. html 

[7] http:/ / www. stevemcconnell. com/ 

[8] http:/ / runtime-basic. net/ Assembler:Funktionen:Beschreibung-Kurz-CPU 

[9] http:/ / www. lcs-chemie. de/ assemb. htm 

[10] http:/ / www. i8086. de/ asm/ 8086-88-asm. html 

[11] http:/ / www. schellong. de/ pent. htm

B (Programmiersprache) 14 

B (Programmiersprache) 

Die Programmiersprache B wurde 1969 von Ken Thompson und Dennis Ritchie entwickelt. B ist stark beeinflusst 

von BCPL und ist Vorgänger der Programmiersprache C. 

B ist vor allem aus sprachhistorischen Gründen interessant, da es die Entwicklung von BCPL zu C genauer 

dokumentiert. Es wurde für die Übersetzung auf einer DEC PDP-7 mit 8 kb RAM entwickelt. Später wurde es auf 

PDP-11-Maschinen und Honeywell-Mainframes portiert, wo es zum Beispiel für das bekannte AberMUD von Alan 

Cox bis in die 1990er-Jahre benutzt wurde. 

Aufgrund der eingeschränkten Hardwareressourcen auf der Zielmaschine PDP-7 fehlen B einige BCPL-Merkmale, 

die die Übersetzung aufwändiger machen würden. Beispielsweise sind keine verschachtelten Funktionsdefinitionen 

möglich. Ebenso wegen der eingeschränkten Ressourcen erzeugte der B-Compiler auf der PDP-7 einen einfachen 

Zwischencode, der von einem Interpreter zur Laufzeit interpretiert werden muss. [1] 

In B gab es wie in BCPL oder Forth nur einen Datentyp, dessen Bedeutung sich erst durch die benutzten Operatoren 

und Funktionen ergab. B ist also typlos. Es gab bereits viele Spracheigenschaften, die man in C finden kann. Einige 

Programme sind sogar ohne Probleme noch mit heutigen C-Compilern übersetzbar. 

Code-Beispiel 

main() { auto c; auto d; d=0; while(1) { c=getchar(); d=d+c; putchar(c); } } Dieses Programm lässt sich auch noch 

mit heutigen C-Compilern (im K&R- oder traditional-Modus) übersetzen. Es ist jedoch kein ANSI-C. 

Weblinks 

• Die originale Sprachspezifikation [2] (englisch) 

• bell-labs.com B-Tutorial [3] (englisch) 

Referenzen 

[1] D. Ritchie, The Development of the C Language (http:/ / cm. bell-labs. com/ cm/ cs/ who/ dmr/ chist. html) in History of Programming 

Languages, ACM Press and Addison-Wesley, 1996, ISBN 0-201-89502-1 

[2] http:/ / cm. bell-labs. com/ cm/ cs/ who/ dmr/ kbman. html 

[3] http:/ / www. cs. bell-labs. com/ cm/ cs/ who/ dmr/ btut. html

BASIC 15 

BASIC 

BASIC ist eine der am weitesten verbreiteten imperativen 

Programmiersprachen. Sie wurde 1964 von John George Kemeny und 

Thomas Eugene Kurtz am Dartmouth College entwickelt und verfügte 

in ihrer damaligen Form noch nicht über die Merkmale der 

strukturierten Programmierung, sondern arbeitete mit Zeilennummern 

und Sprungbefehlen (GOTO). Mittlerweile gibt es eine Vielzahl 

verschiedener BASIC-Dialekte, von denen einige der jüngeren alle 

Elemente höherer Programmiersprachen aufweisen, so etwa 

Objektorientierung. 

Das Apronym „BASIC“ steht für „Beginner’s All-purpose Symbolic 

Instruction Code“, was so viel bedeutet wie „symbolische 

Allzweck-Programmiersprache für Anfänger“. Die Abkürzung als Wort 

gesehen bedeutet außerdem „grundlegend“. Dies zeigt das Design-Ziel 

klar: Eine einfache, für Anfänger geeignete Programmiersprache zu 

erschaffen. Außer in manchen Produktnamen wird das Wort „BASIC“ 

grundsätzlich in Großbuchstaben geschrieben. 

Allgemeines 

Die Sprache wurde aufgrund von acht Prinzipien entworfen: 

• Für Anfänger leicht zu erlernen. 

• Universell einsetzbar. 

• Erweiterbarkeit der Sprache für Experten. 

• Interaktivität. 

• Klare Fehlermeldungen. 

• Kurze Antwortzeiten. 

• Hardwareunabhängigkeit. 

• Betriebssystemunabhängigkeit. 

Geschichte 

Ausschnitt aus einem Basic-Listing 

BASIC wurde 1964 von John George Kemeny und Thomas Eugene Kurtz am Dartmouth College entwickelt, um den 

Elektrotechnikstudenten den Einstieg in die Programmierung gegenüber Algol und Fortran zu erleichtern. Am 1. Mai 

1964 um vier Uhr Ortszeit, New Hampshire, liefen die ersten beiden BASIC-Programme simultan auf einem 

GE-225-Computer von General Electric im Keller des Dartmouth College. BASIC wurde dann viele Jahre lang von 

immer neuen Informatikstudenten an diesem College weiterentwickelt, zudem propagierten Kemeny und Kurtz es ab 

den späten 1960er Jahren an mehreren Schulen der Gegend, die erstmals Computerkurse in ihr Unterrichtsprogramm 

aufnehmen wollten. BASIC war entsprechend dem Wunsch seiner „Väter“ für die Schulen kostenlos, im Gegensatz 

zu fast allen anderen damals üblichen Programmiersprachen, die meist mehrere tausend Dollar kosteten. Viele der 

damaligen großen Computerhersteller (wie etwa DEC) boten wegen der leichten Erlernbarkeit der Sprache und ihrer 

lizenzgebührfreien Verwendbarkeit bald BASIC-Interpreter für ihre neuen Minicomputer an; viele mittelständische 

Unternehmen, die damals erstmals in größerer Zahl Computer anschafften, kamen so mit BASIC in Berührung. 

Einige der so mit BASIC vertrauten Schüler, Studenten und im Mittelstand tätigen Programmierer waren etwas 

später in der kurzlebigen Bastelcomputer-Szene Mitte der 1970er-Jahre aktiv, die den kommerziellen

BASIC 16 

Microcomputern vorausging, und machten BASIC dort bekannt; kaum eine andere damals verbreitete Hochsprache 

eignete sich so gut wie (ein abgespecktes) BASIC für den extrem beschränkten Speicherplatz dieser ersten 

Microcomputer. Seinen Höhepunkt erlebte BASIC mit den aus den Bastelcomputern hervorgehenden ersten 

Heimcomputern. Ende der 1970er- und Anfang der 1980er-Jahre, die nahezu alle als Benutzeroberfläche und 

Programmierumgebung einen BASIC-Interpreter besaßen. Prominente Beispiele sind Sinclair ZX80 und ZX81, der 

Tandy TRS 80, der Schneider/Amstrad CPC, der Apple II, die Atari 8-Bit Heimcomputer oder der meistverkaufte 

Heimcomputer aller Zeiten, der Commodore 64. Aber auch die Vorläufer der Personalcomputer, wie zum Beispiel 

von Philips, konnten mit CP/M-BASIC interpretierend oder kompiliert arbeiten. Die weitaus meisten dieser BASICs 

stammten von Microsoft. BASIC war Microsofts erstes und in den frühen Jahren wichtigstes Produkt, mehrere Jahre 

bevor mit MS-DOS das erste Betriebssystem dieser Firma auf den Markt kam. 

Praktisch alle Besitzer von Heimcomputern hatten damals zumindest Grundkenntnisse in BASIC, da die meisten 

Rechner beim Einschalten den Basic-Interpreter starteten, welcher das Laden weiterer Programme unter 

Verwendung von BASIC-Befehlen erlaubte. Auch als Mitte der 1980er Jahre grafische Benutzeroberflächen mit dem 

Macintosh, Amiga und dem Atari ST Einzug hielten, wurden bei diesen weiter BASIC-Interpreter mitgeliefert. Auch 

gab es zusätzliche käufliche Versionen von BASIC-Dialekten. Mittels Compilern konnten einige BASIC-Dialekte 

direkt in deutlich schnellere Maschinenprogramme übersetzt bzw. unter Umgehung des Interpreters direkt in 

Aufruflisten der zugrundeliegenden Interpreter-Funktionen übersetzt werden. Das seit 1981 verbreitete MS-DOS 

enthielt ebenfalls einen BASIC-Interpreter – zunächst BASICA bzw. GW-BASIC, später QBasic – der in 

Deutschland an vielen Schulen eine Rolle im Unterricht der Informatik spielte. Zu dieser Zeit setzte aber ein Wandel 

ein, weil andere Hochsprachen wie beispielsweise C für die Heimcomputer verfügbar wurden oder die Ressourcen 

des jeweiligen Systems vom mitgelieferten BASIC-Interpreter nur unzulänglich unterstützt wurden, was den 

Programmierer dazu zwang, sich mit Assembler vertraut zu machen. 

Durch die Umsetzung als Interpreter-Sprache waren die frühen BASIC-Dialekte außerdem deutlich langsamer als die 

meisten anderen, in der Regel compilerbasierten Hochsprachen. Dies machte es besonders für zeitkritische 

Anwendungen unattraktiv bzw. führte zur Verwendung von Unterprogrammen in Maschinensprache, die oft mit 

POKE-Anweisungen von BASIC aus in den Hauptspeicher geschrieben wurden. Solche Programme waren natürlich 

nicht portabel. Deshalb und wegen der Zersplitterung in unzählige Dialekte gilt BASIC als fast nicht portabel. Mit 

Einführung von Visual Basic ab Version 5 erzielte Microsoft deutliche Erfolge in Bezug auf die 

Verarbeitungsgeschwindigkeit, die aber den zuvor verlorenen Boden nicht wieder rückgewinnen konnten. 

Mit der Zeit nahm der Anteil der Menschen zu, die einen Computer nur bedienen, aber nicht programmieren 

konnten. Hauptgrund dafür, dass BASIC zwischenzeitlich fast in Vergessenheit geraten war, war aber, dass nach 

dem Zusammenbruch der großen Heim- und Bürocomputer-Hersteller Atari und Commodore der Markt von 

Windows-PCs dominiert wurde. Bei diesen war kein BASIC-Interpreter inbegriffen, mit dem man 

Windows-Programme hätte schreiben können. 

Microsoft besann sich allerdings auf die eigene Tradition und führte das kommerzielle Visual Basic für die schnelle 

Entwicklung von Windows-basierten Anwendungen ein. Der Code wurde nicht mehr zur Laufzeit interpretiert, 

sondern von einem Compiler während der Programmentwicklung in maschinennahen Bytecode beziehungsweise in 

späteren Versionen sogar in nativen Maschinencode übersetzt. Durch diese Maßnahme konnte die Geschwindigkeit 

und die Stabilität der Programmausführung deutlich gesteigert werden. Da auch die Geschwindigkeit der Computer 

immer mehr zunahm, wurde Visual Basic außerdem für professionelle Entwicklungen immer interessanter. Mit 

Einführung von objektorientierten Sprachelementen wurde der Versuch unternommen, Visual Basic mit anderen 

objektorientierten Programmiersprachen wie C++ gleichziehen zu lassen. 

Basic wird in den Office-Produkten von Microsoft und auch in einigen weiteren Anwendungen als VBA erfolgreich 

zur internen Makro-Programmierung eingesetzt. Viele Softwarehersteller bieten ebenfalls auf Basic basierende 

Programmiersprachen zur internen Makro-Programmierung ihrer Produkte an.

BASIC 17 

Besonders in Europa hat sich Visual Basic in der Entwicklergemeinschaft nur in begrenztem Maße behaupten 

können. Es bot zwar eine bessere und viel einfachere Anbindung an Windows als jede andere Programmiersprache, 

war aber langsamer. Erst mit der Implementierung von Visual Basic innerhalb des .NET-Systems gelang es, die 

strukturellen Schwächen von BASIC zu überwinden. Gleichzeitig aber bedeutete dieser Schritt das Ende von Visual 

Basic als eigenständige Programmiersprache. Innerhalb des .NET-Systems handelt es sich bei Visual Basic .NET nur 

noch um eine Sprach-Implementierung neben anderen. Mit Einführung der JIT-Compiler und .NET als Basis für alle 

Microsoft-Sprachen besteht zwischen der Verarbeitungsgeschwindigkeit von BASIC und anderen 

Programmiersprachen kein großer Unterschied mehr. 

Das Ziel einer plattformunabhängigen Programmiersprache hat sich nie erfüllt. Im Gegensatz zum gut 

standardisierten C entstanden von BASIC hunderte Dialekte, die allesamt bis auf gewisse grundsätzliche 

Ähnlichkeiten inkompatibel zueinander sind. Die Gemeinsamkeiten beschränken sich auf die reine 

Datenverarbeitung, während jeder Hersteller im Zuge der gleichzeitig verlaufenden rasanten Hardware-Entwicklung 

seine eigenen, auf die jeweilige Hardware abgestimmten Befehle für Ein- und Ausgabe implementierte. 

Programmiersprache 

Zu Beginn der Basic-Programmierung bauten sich Befehle wie folgt auf: 

1. Zeilennummer Befehl [Parameter1, Parameter2 ...] 

2. Zeilennummer Variable1=Variable2 

Zeilennummer: Ein fortlaufender Wert, der i. d. R. in 10er-Schritten ansteigt, damit später nachträglich Zeilen (mit 

Befehlen) hinzugefügt werden können, die dann dazwischen liegende Nummern erhalten. 

Befehl: Ein beliebiger Befehl wie INPUT. 

Parameter: Ein oder mehrere Werte, die einem Befehl übergeben werden können. 

Die Zuweisung von Werten ist in Beispiel 2 unten gezeigt. Die Variable, der ein Wert zugewiesen werden soll, steht 

vor dem Gleichheitszeichen; der Ausdruck, dessen Wert der Variablen zugewiesen werden soll, steht dahinter. 

Beispiele für übliche Befehle: 

INPUT [Text], Variable1 [,Variable2,...] - Per Eingabe werden der/den 

Variablen Werte zugewiesen auf dem Bildschirm steht Text 

PRINT [Text] - auf dem Bildschirm wird ein Text ausgegeben 

LOCATE X,Y - Legt die aktuelle Schreibposition des Cursors fest. 

PSET X,Y - Zeichnet einen Punkt auf dem Bildschirm 

CLS - Löscht den Anzeigebereich 

Programmierbeispiel 

Das folgende Beispiel zeigt einen typischen BASIC-Code. Viele Befehle, die sich in neueren Sprachen etabliert 

haben, gibt es bei dem im Beispiel verwendeten BASIC noch nicht. Dadurch war der Programmierer gezwungen, 

unstrukturiert zu programmieren. Ein Vorteil von BASIC war jedoch, dass es einfache Möglichkeiten zur 

Zeichenkettenverarbeitung bereithielt (siehe Zeile 70 - 90 im Beispielprogramm). 

10 INPUT "Geben Sie bitte Ihren Namen ein"; A$ 

20 PRINT "Guten Tag, "; A$ 

30 INPUT "Wie viele Sterne möchten Sie?"; S 

35 S$ = "" 

40 FOR I = 1 TO S 

50 S$ = S$ + "*"

BASIC 18 

55 NEXT I 

60 PRINT S$ 

70 INPUT "Möchten Sie noch mehr Sterne?"; Q$ 

80 IF LEN(Q$) = 0 GOTO 70 

90 L$ = LEFT$(Q$, 1) 

100 IF (L$ = "J") OR (L$ = "j") THEN GOTO 30 

110 PRINT "Auf Wiedersehen"; 

120 FOR I = 1 TO 200 

130 PRINT A$; " "; 

140 NEXT I 

150 PRINT 

Standards 

• ANSI. ISO Standard for Minimal BASIC (ISO/IEC 6373:1984 “DATA PROCESSING—PROGRAMMING 

LANGUAGES—MINIMAL BASIC”) 

• ANSI Standard. ISO Standard für Vollbasic (ISO/IEC 10279:1991 “INFORMATION 

TECHNOLOGY—PROGRAMMING LANGUAGES—FULL BASIC”) 

• ANSI Addendum Defining Modules (X3.113 INTERPRETATIONS-1992 “BASIC TECHNICAL 

INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI 03.113-1987”) 

• ISO Addendum Defining Modules (ISO/IEC 10279:1991/ Amd 1:1994 “MODULES AND SINGLE 

CHARACTER INPUT ENHANCEMENT”) 

Die meisten existierenden Interpreter und Compiler halten sich allerdings nicht oder nur teilweise an diese 

Vorgaben. 

Literatur 

• Dr. Hans-Joachim Sacht: BASIC-Dialekte. Humboldt-Taschenbuchverlag, München 1985, ISBN 3-581-66524-7. 

• Rüdeger Baumann: BASIC – Eine Einführung in das Programmieren. Klett Verlag, Stuttgart 1980 ISBN 

3-12-717700-3 

• Dr. Hans-Joachim Sacht: Programmiersprache BASIC – Schritt für Schritt. Humboldt-Taschenbuchverlag, 

München 1983 ISBN 3-581-66456-9 

Weblinks 

• Offizielle deutsche KBasic-Seite [1] 

• DseWiki: Deutsches Software Entwickler Wiki [2] 

• BASIC-Tutorial für absolute Neulinge [3] 

• Basic Tutorial für Einsteiger [4] 

• Übersicht über die BASIC-Befehle [5] 

• BASIC [6] 

• GAMBAS [7] 

• Die größte deutsche Seite zu QBasic [8] 

• Liste von BASIC-Compilern mit Screenshots [9] (englisch)

BASIC 19 

Referenzen 

[1] http:/ / www. KBasic. de 

[2] http:/ / www. wikiservice. at/ dse/ wiki. cgi?SpracheBasic 

[3] http:/ / www. o-bizz. de/ qbtuts/ omastut/ index. htm 

[4] http:/ / www. tutorials. at 

[5] http:/ / www. chemie. fu-berlin. de/ lehre/ edv/ basic. html 

[6] http:/ / www. madeasy. de/ 2/ basic. htm 

[7] http:/ / www. madeasy. de/ 7/ gambas. htm 

[8] http:/ / www. qbasic. de 

[9] http:/ / basic. mindteq. com 

Borland Delphi 

1. WEITERLEITUNG Embarcadero Delphi 

C (Programmiersprache) 

Paradigmen: imperativ, strukturiert 

Erscheinungsjahr: 1972 

Entwickler: Dennis Ritchie & Bell Labs 

wichtige Implementierungen: GCC, MSVC, Borland C, Portland Group, Intel 

Einflüsse: B (BCPL,CPL), ALGOL 68, Assembler 

C 

Beeinflusste: awk, C++, C#, Objective-C, D, Java, JavaScript, Perl, PHP 

C ist eine imperative Programmiersprache, die der Informatiker Dennis Ritchie in den frühen 1970er Jahren an den 

Bell Laboratories für das Betriebssystem Unix entwickelte. Seitdem ist sie auf vielen Computersystemen verbreitet. 

Die Anwendungsbereiche von C sind sehr verschieden. Es wird zur System- und Anwendungsprogrammierung 

eingesetzt. Die grundlegenden Programme aller Unix-Systeme und die Systemkerne vieler Betriebssysteme sind in C 

programmiert. Zahlreiche Sprachen, wie C++, Objective-C, C#, Java, PHP oder Perl orientieren sich an der Syntax 

und anderen Eigenschaften von C. 

Überblick 

C ist eine Programmiersprache, die auf fast allen Computersystemen zur Verfügung steht. Sie zählt zu den 

sogenannten prozeduralen Programmiersprachen. Um den Wildwuchs zahlreicher Dialekte einzudämmen, wurde C 

mehrfach standardisiert (C89, C95, C99, ISO-C). Abgesehen vom Mikrocontrollerbereich, wo eigene Dialekte 

existieren, sind die meisten aktuellen PC-/Server-Implementierungen eng an den Standard angelehnt; eine 

vollständige Implementierung aktueller Standards ist aber selten. In den meisten C-Systemen mit Laufzeitumgebung 

steht auch die genormte Standard C Library zur Verfügung. Dadurch können C-Programme, die keine sehr 

hardware-nahe Programmierung enthalten, in der Regel gut auf andere Zielsysteme portiert werden. Konzeptionell 

ist C auf einfache Kompilierbarkeit ausgelegt. Die Compiler erzeugen in der Regel aber auch nur wenig Code zur 

Gewährleistung der Sicherheit zur Laufzeit der Programme. 

Die Verbreitung von C ist hoch, und viele Programmierschnittstellen für Anwendungsprogramme werden in Form 

von C-Schnittstellen implementiert.


Geschichte 

Frühe Entwicklungen 

C wurde 1971–1973 von Dennis Ritchie in den Bell Laboratories für die Programmierung des damals neuen 

UNIX-Betriebssystems entwickelt. Er stützte sich dabei auf die Programmiersprache B, die Ken Thompson in den 

Jahren 1969/70 geschrieben hatte. B wiederum geht auf die von Martin Richards Mitte der 1960er-Jahre entwickelte 

Programmiersprache BCPL zurück. Ritchie schrieb auch den ersten Compiler für C. 1973 war die Sprache so weit 

ausgereift, dass man nun den Unix-Kernel für den PDP-11 neu in C schreiben konnte. 

K&R C 

1978 veröffentlichten Brian W. Kernighan und Dennis Ritchie die erste Auflage von The C Programming Language 

(deutsch: Programmieren in C). Die darin beschriebene Fassung von C, die nach den Buchautoren „K&R C“ genannt 

wird, erweiterte die ursprüngliche Sprache um neue Schlüsselwörter wie long int oder unsigned int und führte 

erstmals die I/O-Standardbibliothek ein. Bis zur Standardisierung der Sprache diente die von Kernighan und Ritchie 

geschriebene Spezifikation als informelle Referenz für das Programmieren in C. 

Normen und Standards 

→ Hauptartikel: Varianten der Programmiersprache C 

C verbreitete sich rasch und wurde laufend weiterentwickelt. Das führte dazu, dass das von Kernighan und Ritchie 

beschriebene C nicht mehr dem C entsprach, das von den Compilern unterstützt wurde. Um eine Normierung der 

Sprache zu erreichen, setzte das American National Standards Institute (ANSI) 1983 ein Komitee namens X3J11 ein, 

das 1989 schließlich die Norm ANSI X3.159-1989 Programming Language C verabschiedete. Ein Jahr später 

übernahm die ISO diesen Standard (mit kleinen Änderungen) als C90. 1995 veröffentlichte die ISO eine Ergänzung 

zum Standard (C95) und 1999 schließlich ISO/IEC 9899:1999. Mit diesem Standard, der als C99 bekannt ist, flossen 

auch aus C++ bekannte Erweiterungen zurück in die Sprache C. 

Verwendung 

Das Haupteinsatzgebiet von C liegt in der Systemprogrammierung, einschließlich der Erstellung von 

Betriebssystemen und der Programmierung von eingebetteten Systemen. Der Grund liegt in der Kombination von 

erwünschten Charakteristiken wie Portabilität und Effizienz mit der Möglichkeit, Hardware direkt anzusprechen und 

dabei niedrige Anforderungen an die Laufzeitumgebung zu haben. 

Auch Programme für Endanwender werden oft in C erstellt. 

Wegen der relativ hohen Geschwindigkeit und geringen Codegröße werden Compiler, Programmbibliotheken und 

Interpreter anderer höherer Programmiersprachen (wie zum Beispiel die Java Virtual Machine) oft in C 

implementiert. 

C wird als Zwischencode einiger Implementierungen höherer Programmiersprachen verwendet. Dabei wird diese 

zuerst in C-Code übersetzt, der dann kompiliert wird. Dieser Ansatz wird entweder verwendet, um die Portabilität zu 

erhöhen (C-Compiler existieren für nahezu jede Plattform) oder aus Bequemlichkeit, da kein maschinenspezifischer 

Codegenerator entwickelt werden muss. Einige Compiler, die C auf diese Art benutzen, sind EiffelStudio, Esterel, 

Gambit, der Glasgow Haskell Compiler, einige LISP-Compiler, Lush, PyPy, Sather, Squeak und Vala. 

C wurde als Programmiersprache und nicht als Zielsprache für Compiler entworfen. Als Zwischensprache ist es 

daher eher schlecht geeignet. Das führte zu C-basierten Zwischensprachen wie C--. 

C wird oft für die Erstellung von Anbindungen genutzt (zum Beispiel Java Native Interface). Diese Anbindungen 

erlauben es Programmen, die in einer anderen Hochsprache geschrieben sind, Funktionen aufzurufen, die in C 

implementiert wurden. Der umgekehrte Weg ist oft ebenfalls möglich und kann verwendet werden, um in C


geschriebene Programme mit einer anderen Sprache zu erweitern (zum Beispiel mod perl). 

Eigenschaften 

• C gehört zu den imperativen Programmiersprachen. 

• C besitzt eine relativ kleine Menge an Schlüsselwörtern. Die Anzahl der Schlüsselwörter ist so gering, weil viele 

Aufgaben, welche in anderen Sprachen über eigene Schlüsselwörter realisiert werden, über einzubindende 

Bibliotheksroutinen (zum Beispiel die Ein- und Ausgabe auf der Konsole oder Dateien und die Verwaltung des 

dynamischen Speichers) oder über spezielle syntaktische Konstrukte (zum Beispiel Variablendeklarationen) 

realisiert werden. 

• C ermöglicht direkte Speicherzugriffe und sehr hardwarenahe Konstrukte. Es eignet sich daher gut zur 

Systemprogrammierung. Sollen Programme portierbar sein, sollte von diesen Möglichkeiten aber möglichst 

wenig Gebrauch gemacht werden. 

• C schränkt direkte Speicherzugriffe kaum ein. Dadurch kann der Compiler (anders als zum Beispiel in Pascal) nur 

sehr eingeschränkt bei der Fehlersuche helfen. Aus diesem Grund ist C für sicherheitskritische Anwendungen 

(Medizintechnik, Verkehrsleittechnik, Raumfahrt) weniger geeignet. 

• C enthält einige sicherheitskritische Funktionen; so überschreibt zum Beispiel gets(), eine Funktion der 

Standardbibliothek, fremde Speicherbereiche (Pufferüberlauf), wenn es auf eine unpassende (zu lange) Eingabe 

stößt. Der Fehler ist innerhalb von C weder bemerk- noch abfangbar. Um den großen Vorteil von C – die 

Existenz zahlreicher älterer Quellcodes – nicht zu verlieren, unterstützen auch aktuelle Implementierungen 

weiterhin diese und ähnliche Funktionen, warnen jedoch in der Regel, wenn sie beim Übersetzen im Quelltext 

benutzt werden. 

• Historisch bedingt existieren in C keine Funktionen zur positionierten Ausgabe. Es existieren jedoch zahlreiche 

Bibliotheken, die für das jeweilige Zielsystem eine solche Ausgabe ermöglichen. 

• C verwendet im Quellcode einige Sonderzeichen (zum Beispiel „{“, „|“ und „&“), die in der Vergangenheit nicht 

auf allen Zielsystemen zur Verfügung standen. Das hat dazu geführt, dass C sich auf jenen Systemen nicht 

verbreiten konnte. C bietet zwar eine Alternativschreibweise über Trigraphen, was jedoch die Lesbarkeit des 

Quelltextes enorm verschlechtert. 

• Eine Modularisierung in C erfolgt auf Dateiebene. Eine Datei bildet eine Übersetzungseinheit; intern benötigte 

Funktionen und Variablen können so vor anderen Dateien verborgen werden. Die Bekanntgabe der öffentlichen 

Funktionsschnittstellen erfolgt mit sogenannten Header-Dateien. Damit verfügt C über ein schwach ausgeprägtes 

[1] [2] 

Modulkonzept. 

Die Programmiersprache C wurde mit dem Ziel entwickelt, eine echte Sprachabstraktion zur Assemblersprache zu 

implementieren. Es sollte eine direkte Zuordnung zu wenigen Maschineninstruktionen geben, um die Abhängigkeit 

von einer Laufzeitumgebung zu minimieren. Als Resultat dieses Designs ist es möglich, C-Code auf einer sehr 

hardwarenahen Ebene zu schreiben, analog zu Assemblerbefehlen. Die Portierung eines C-Compilers auf eine neue 

Prozessorplattform ist, verglichen mit anderen Sprachen, wenig aufwändig. Beispielsweise ist der freie 

GNU-C-Compiler (gcc) für eine Vielzahl unterschiedlicher Prozessoren und Betriebssysteme verfügbar. Für den 

Entwickler bedeutet das, dass unabhängig von der Zielplattform fast immer auch ein C-Compiler existiert. C 

unterstützt damit wesentlich die Portierbarkeit von Programmen, sofern der Programmierer auf Assemblerteile im 

Quelltext und/oder hardwarespezifische C-Konstrukte verzichten kann. Bei der Mikrocontroller-Programmierung ist 

C die mit Abstand am häufigsten verwendete Hochsprache.


Datentypen 

Jeder Ausdruck und jeder Bezeichner in C hat einen bestimmten Datentyp. C unterscheidet zwischen: 

• Objekttypen (object types) 

• Funktionstypen (function types) 

• unvollständige Typen (incomplete types) 

Außerdem wird zwischen Basisdatentypen (basic types) und abgeleiteten Typen (derived types) unterschieden. 

Basisdatentypen 

C verfügt über 19 Basisdatentypen (eng. basic types). Diese werden in Datentypen für Ganzzahl-, und 

Gleitkommazahlen aufgeteilt. Die verschiedenen Typen ermöglichen bei unterschiedlichem Speicherbedarf das 

Speichern von Daten aus einem unterschiedlich großen maximalen Wertebereich. 

• void ist der leere Datentyp. Er kann keine Werte aufnehmen. void ist ein unvollständiger Typ, darum können 

keine Variablen von diesem Typ deklariert werden. Ein Rückgabetyp void bedeutet, dass die Funktion keinen 

Wert zurückgibt. Eine Variable vom Typ void * zeigt auf Objekte mit unspezifiziertem Typ. 

• _Bool dient zur Repräsentation von Wahrheitswerten. Er existiert als eigener Datentyp seit C99 und kann nur die 

Werte 0 und 1 aufnehmen. Die Größe eines _Bools ist plattformabhängig und kann größer als ein char sein! 

• char und wchar_t dienen zur Speicherung alphanumerischer Daten. Sie werden in C als Ganzzahl-Datentypen 

(mit besonderen Eigenschaften) behandelt. Außerdem repräsentiert ein char die kleinste adressierbare Einheit in 

C. Die Größe von Objekten und Typen wird stets als ganzzahliges Vielfache von einem char angegeben. 

• int ist der Standarddatentyp für ganzzahlige Werte. Für eventuell größere oder kleinere Wertebereiche existieren 

die Typen char, short int, long int und (seit C99) long long int. Der Verzicht auf festgeschriebene Größen und 

Wertebereiche, um möglichst viele Architekturen zu unterstützen, wird durch definierte minimale Wertebereiche 

und die folgende feste Relation abgemildert: 

signed char ≤ short int ≤ int ≤ long int ≤ long long int. 

(„≤“ bedeutet dabei, dass der rechts stehende Typ alle Werte des links stehenden Typs aufnehmen kann.) 

Zu all diesen Typen existieren noch vorzeichenlose Typen, die durch ein vorangestelltes unsigned notiert 

werden. Diese benötigen den gleichen Speicherplatz wie ihre entsprechenden vorzeichenbehafteten Typen. 

Optional können die vorzeichenbehafteten Typen auch durch ein vorangestelltes signed gekennzeichnet 

werden und das Schlüsselwort int kann bei den mehrteiligen Typnamen entfallen. 

Der Typ char ist ein eigener Datentyp, der jedoch – je nach Plattform – entweder zu signed char oder zu 

unsigned char ein identisches Bit-Layout und identische Rechenregeln besitzen muss. 

Für jeden Typ schreibt der Standard eine Mindestgröße vor; In einer Implementierung können die Werte auch 

größer sein. Die tatsächliche Größe eines Typs ist in der Headerdatei abgelegt. INT_MAX ersetzt 

der Präprozessor beispielsweise durch den Wert, den der Typ int maximal annehmen kann. [3] 

• float, double und long double sind die drei Datentypen für Gleitkommazahlen. Auf den meisten Architekturen 

entsprechen float und double den IEEE-Datentypen. Welchen Wertebereich ein Gleitkommazahltyp auf einer 

Implementierung einnimmt, ist ebenfalls plattformabhängig; der Standard legt nur wieder fest, dass der 

Wertebereich von float nach double und von double nach long double jeweils entweder gleich bleibt oder 

zunimmt. Die genauen Eigenschaften und Wertebereiche auf der benutzten Architektur können über die 

Headerdatei ermittelt werden. [4] 

Zusätzlich existieren seit C99 noch drei Gleitkomma-Datentypen für komplexe Zahlen, welche aus den drei 

Gleitkommatypen abgeleitet sind: float _Complex, double _Complex und long double _Complex. Ebenfalls in C99 

eingeführt wurden Gleitkomma-Datentypen für rein imaginäre Zahlen: float _Imaginary, double _Imaginary und 

long double _Imaginary. Diese 3 Typen sind jedoch auch in einer hosted-Umgebung optional, während die


_Complex-Typen nur in einer freestanding-Umgebung entfallen dürfen. [5] 

Abgeleitete Typen 

Aus den Basisdatentypen und bereits deklarierten abgeleiteten Typen lassen sich beliebig viele weitere Typen 

ableiten. Abgeleitete Typen werden wie folgt aufgeteilt: 

Felder (array types) 

Zu jedem Typ T existieren Feldtypen derart „Feld von n Elementen vom Typ T“, die dann T[n] geschrieben 

werden. 

Zeiger (pointer types) 

Zu jedem Typ T existiert ein Typ „Zeiger auf T“, der T* geschrieben wird. 

Funktionen (function types) 

Zu jedem Typ T existieren Typen „Funktion, die ein T zurückgibt“. Dies wird durch Anhängen von () 

gekennzeichnet, wobei in die Klammern ggf. noch die Typen der Funktionsparameter geschrieben werden. 

zusammengesetzte Typen (structure types und union types) 

Hierbei werden mehrere Objekte zu einem neuen Typ zusammengefasst. 

Deklarationen 

Bevor Variablen, Typen und Funktionen in C verwendet werden können, müssen sie deklariert werden. Eine so 

deklarierte Variable, Typ oder Funktion erhält einen Namen (Bezeichner). Die Vergabe von Bezeichnern ist an 

bestimmte Regeln gebunden: 

• Das erste Zeichen eines Variablennamens muss ein Buchstabe oder Unterstrich sein. 

• Die folgenden Zeichen dürfen nur die Buchstaben A–Z und a–z, Ziffern und der Unterstrich sein. 

• Ein Bezeichner darf kein Schlüsselwort der Sprache – zum Beispiel if, void und auto – sein. 

Seit C95 sind auch Zeichen aus dem Universal Character Set in Bezeichnern erlaubt, sofern die Implementierung es 

unterstützt. Die erlaubten Zeichen sind in Anhang D des ISO-C-Standards aufgelistet. Vereinfacht gesagt, sind es all 

jene Zeichen, die in irgendeiner Sprache als Buchstabe oder buchstabenähnliches Zeichen Verwendung finden. Im 

Quelltext lassen sich diese Zeichen plattformunabhängig über eine Escape-Sequenz wie folgt ersetzen: 

• \uXXXX (wobei X für eine Hexadezimalziffer steht) für Zeichen mit einem Code von 00A0 hex bis FFFF hex . 

• \UXXXXXXXX für alle Zeichen mit einem Code ≥00A0 hex . 

Das folgende Beispiel in der Programmiersprache C deklariert und definiert die Namen variable_1 und 

variable_2 als Variablen vom Typ Integer: 

void beispiel1() 

{ 

} 

int variable_1, variable_2; 

Sprachdesign 

Ein C-Programm wird durch den sogenannten Linker oder Binder aus Objektcode zum ausführbaren 

Computerprogramm gebunden. Dabei können mehrere Objektcodedateien zu einem Programm zusammengefasst 

werden. Die Objektcodedateien ihrerseits werden durch den Compiler aus Textdateien erzeugt (übersetzt), die eine 

Anzahl Funktions- und Variablendefinitionen enthalten. Neben Programmen kann man aber auch noch Bibliotheken 

erstellen. Diese werden ähnlich wie Programme gebunden oder zu einem Archiv zusammengefasst. Diese 

Bibliotheken können dann in einem späteren Bindevorgang wiederum zu einem Programm hinzugebunden werden.


Auf diese Weise kann man verhindern, dass für jedes zu erzeugende Programm unzählige (in größeren Systemen 

durchaus hunderte bis tausende) unveränderliche Objektcodedateien immer wieder erneut gebunden werden müssen. 

Das Design der Programmiersprache, die Technik des Linkens und verschiedene zu festen Sprachelementen 

gewordene Funktionen und Festlegungen sind eng mit dem Design unixoider Betriebssysteme verbunden, so die Art 

und Weise der Signalbearbeitung, die Ein- und Ausgabe mit Standard-Datenströmen (Streams) und das Verfahren 

des Startens und Beendens eines Programms. 

Beispielprogramm in C 

Der folgende Quelltext stellt ein einfaches C-Programm dar, das die Textzeile Hallo Welt!, gefolgt von einem 

Zeilenumbruch, ausgibt. Dieses Beispiel folgt den Vorgaben des ANSI-C-Standards; andere Versionen dieses 

Programms sind im Artikel Hallo-Welt-Programm beschrieben. 

#include 


int main(void) 

{ 

printf("Hallo Welt!\n"); 

return EXIT_SUCCESS; 

} /* end main() */ 

Erläuterungen 

In der ersten Zeile ermöglicht die Präprozessoranweisung #include die spätere Verwendung von 

Funktionen aus der Ein-/Ausgabe-Bibliothek stdio (auch „standard-input/output“ genannt). Diese include-Anweisung 

veranlasst den C-Präprozessor, vor der Übersetzung die Headerdatei stdio.h in den Quelltext zu kopieren, die unter 

anderem eine Deklaration der weiter unten verwendeten Ausgabefunktion printf enthält. In der zweiten Zeile wird 

die Headerdatei stdlib.h eingebunden, die anstatt eines festen numerischen Werts die symbolische Konstante 

EXIT_SUCCESS definiert, damit die erfolgreiche Programmausführung dem Aufrufer plattformunabhängig 

signalisiert werden kann (siehe Zeile 7 des Programms). Include-Anweisungen können zwar an jeder Stelle im 

Quelltext eingefügt werden, meist werden sie jedoch an den Anfang eines Programmtextes gestellt, um die 

Übersichtlichkeit zu erhöhen. 

In der vierten Zeile beginnt das eigentliche Programm mit der Definition der Funktion main. Sie ist die 

Einstiegsfunktion eines C-Programms. main wird automatisch als erste Funktion aufgerufen. Anfang und Ende der 

Funktion main werden durch die beiden geschweiften Klammern markiert. 

Die erste Anweisung innerhalb der Funktion main ruft die Funktion printf auf. Die zweite Anweisung ist die 

Sprunganweisung return EXIT_SUCCESS;. Diese legt den Rückgabewert von main fest. Damit wird der 

„Erfolgsstatus“ des ausgeführten Programms zum Ausdruck gebracht. Der Wert EXIT_SUCCESS bedeutet hier 

fehlerfreie Ausführung. 

In der letzten Zeile folgt auf die schließende geschweifte Klammer ein Kommentar, eingeschlossen durch die 

Zeichenfolgen /* und */. Kommentare werden bei der Übersetzung ignoriert; sie sind in erster Linie für den 

menschlichen Leser gedacht, können aber auch von automatischen Software-Dokumentationswerkzeugen 

ausgewertet werden.


Die Standardbibliothek 

Die C-Standardbibliothek ist integraler Bestandteil einer gehosteten C-Implementation. Sie enthält unter anderem 

Makros und Funktionen, die mittels der Standard-Header-Datei verfügbar gemacht werden. Auf freistehenden 

Implementationen dagegen kann der Umfang der Standardbibliothek eingeschränkt sein. 

Literatur 

• Brian W. Kernighan, Dennis Ritchie: Programmieren in C, Hanser Fachbuch, 2. Auflage, 1990, ISBN 

3-446-15497-3. 

• Samuel P. Harbison III, Guy Lewis Steele junior: C a reference manual, Prentice Hall, 2002, ISBN 

0-13-089592-X. 

Weblinks 

• Ritchie über die Geschichte von C [6] (englisch) 

• Abhandlung über die Urzeiten von C und Compilerversionen von 1972/73 [7] (englisch) 

• Programming in C – umfangreiche Linksammlung [8] (englisch) 

• FAQ [9] der Newsgroup de.comp.lang.c 

• C von A bis Z [10] Onlinebuch Einstieg in C von Jürgen Wolf 

Referenzen 

[1] Scheler, Stilkerich, Schröder-Preikschat: Komponenten/Module (PDF) (http:/ / www4. informatik. uni-erlangen. de/ Lehre/ SS07/ V_EZS2/ 

Skript/ 05_Komponenten. pdf) 

[2] Bertrand Meyer: Objektorientierte Softwareentwicklung. Hanser, Wien, München; Prentice Hall Internat. 1990, S. 406 ISBN 3-446-15773-5. 

[3] Klaus Schmaranz: Softwareentwicklung in C, Springer, 2001, Seite 29 ff. 

[4] Helmut Herold und Wolfgang Unger: "C"-Gesamtwerk, te-wi Verlag, 2. Auflage, München, 1992, 2-5 bis 2-7 

[5] ISO/IEC 9899:1999 Kapitel 7.6.2 Absatz 3 

[6] http:/ / cm. bell-labs. com/ cm/ cs/ who/ dmr/ chist. html 

[7] http:/ / cm. bell-labs. com/ cm/ cs/ who/ dmr/ primevalC. html 

[8] http:/ / www. lysator. liu. se/ c/ 

[9] http:/ / www. dclc-faq. de/ inhalt. htm 

[10] http:/ / www. galileocomputing. de/ openbook/ c_von_a_bis_z/

C++ 26 

C+ + 

C++ 

Paradigmen: Multiparadigmen (imperativ, strukturiert, objektorientiert, generisch, funktionale) 


Entwickler: Bjarne Stroustrup 

Typisierung: statisch, explizit, schwach 

wichtige Implementierungen: C++ Builder, 

GCC, 

MS Visual C++, 

Intel C++ Compiler 

Standardisierungen: ISO/IEC C++ 1998, 

ISO/IEC C++ 2003 

Einflüsse: C, Simula, Ada, ALGOL 68, CLU, ML 

Beeinflusste: C#, Java, PHP, Perl, D, Go 

C++ ist eine von der ISO standardisierte höhere Programmiersprache. Sie wurde ab 1979 von Bjarne Stroustrup bei 

AT&T als Erweiterung der Programmiersprache C entwickelt. C++ wurde als Mehrzwecksprache konzipiert und 

unterstützt mehrere Programmierparadigmen, wie die objektorientierte, generische und prozedurale 

Programmierung. C++ ermöglicht sowohl die effiziente und maschinennahe Programmierung, als auch eine 

Programmierung auf hohem Abstraktionsniveau. 

Anwendungsgebiete 

C++ wird sowohl in der Systemprogrammierung als auch in der Anwendungsprogrammierung eingesetzt. Typische 

Anwendungsfelder in der Systemprogrammierung sind Betriebssysteme, eingebettete Systeme, virtuelle Maschinen, 

Treiber und Signalprozessoren. C++ nimmt hier oft den Platz ein, der früher ausschließlich Assemblersprachen und 

der Programmiersprache C vorbehalten war. Aus der Domäne der Anwendungsprogrammierung wurde C++ mit dem 

Aufkommen der Sprachen Java und C# zum Teil zurückgedrängt. 

Eigenschaften 


Die Sprache C++ legt einen Schwerpunkt auf die Sprachmittel zur Entwicklung von Bibliotheken und favorisiert 

dadurch verallgemeinerte Mechanismen gegenüber in die Sprache integrierten Einzellösungen für typische 

Problemstellungen. 

Eine der Stärken von C++ ist auch die Kombinierbarkeit von effizienter, maschinennaher Programmierung mit 

mächtigen Sprachmitteln, die einfache bis komplexe Implementierungsdetails zusammenfassen und weitgehend 

hinter abstrakten Befehlsfolgen verbergen. Dabei kommt vor allem die Template-Metaprogrammierung zum Zuge, 

eine Technik, die eine nahezu kompromisslose Verbindung von Effizienz und Abstraktion erlaubt.

C++ 27 

Kompatibilität mit C 

Um an die Verbreitung der Programmiersprache C anzuknüpfen, wurde C++ als Erweiterung von C gemäß dem 

damaligen Stand von 1990 (ISO/IEC 9899:1990, auch kurz C90 genannt) entworfen. 

Die Kompatibilität mit C zwingt C++ aber auch zur Fortführung einiger dadurch übernommener Nachteile. Dazu 

zählt die teilweise schwer verständliche C-Syntax, der als überholt geltende Präprozessor sowie verschiedene von 

der jeweiligen Plattform abhängige Details der Sprache. Plattformabhängigkeiten erschweren die Portierung von 

C++-Programmen zwischen unterschiedlichen Rechnertypen, Betriebssystemen und Compilern. 

Die letzten Änderungen an C fanden im Jahr 1999 statt (ISO/IEC 9899:1999, auch kurz C99 genannt), also nach der 

Normung von C++, sodass dort eingeflossene Änderungen nicht in C++ berücksichtigt werden konnten. C-Compiler, 

die den Stand der ISO-Norm von 1999 umsetzen, sind aber noch nicht sehr verbreitet. Die theoretisch dadurch 

entstandenen Inkompatibilitäten spielen deshalb in der Praxis bislang keine große Rolle. Um dennoch einem 

Auseinanderdriften der Sprachen vorzubeugen, werden die Spracherweiterungen von C bei der in Arbeit 

befindlichen C++-Version berücksichtigt. 

Sprachmerkmale im Detail 

C++ basiert auf der Programmiersprache C wie in ISO/IEC 9899:1990 beschrieben. Zusätzlich zu den in C 

vorhandenen Möglichkeiten bietet C++ weitere Datentypen sowie neuartige Typenumwandlungsmöglichkeiten, 

Klassen mit Mehrfachvererbung und virtuellen Funktionen, Ausnahmebehandlung, Templates (Schablonen), 

Namensräume, Inline-Funktionen, Überladen von Operatoren und Funktionsnamen, Referenzen, Operatoren zur 

Freispeicherverwaltung und mit der C++-Standardbibliothek eine erweiterte Bibliothek. 

C++ ist eine so genannte „Multiparadigmen-Sprache“, die verschiedene Programmiertechniken unterstützt: 

• Prozedurale Programmierung 

• Modulare Programmierung 

• Strukturierte Programmierung 

• Programmierung mit selbstdefinierten Datentypen (abstrakte Datentypen) 

• Objektorientierte Programmierung (siehe auch Polymorphie (Vielgestaltigkeit)) 

• Generische Programmierung mittels Templates. 

Siehe auch: Programmierparadigma, C++-Metaprogrammierung 

Hallo-Welt-Programm in C++ 

Der folgende Quelltext stellt ein einfaches C++-Programm dar, das die Meldung „Hallo Welt!“ auf dem 

Standardausgabemedium ausgibt: 



int main() 

{ 

} 

std::cout

C++ 28 

Umsetzung 

C++-Compiler 

Die Implementierung eines C++-Compilers gilt als aufwändig. Seit der Fertigstellung der Sprachnorm 1998 dauerte 

es mehrere Jahre, bis die Sprache von C++-Compilern weitestgehend unterstützt wurde. 

Zu den bedeutendsten C++-Compilern gehören: 

• Der g++ ist die C++-Ausprägung der GNU Compiler Collection (GCC); g++ ist quelloffen, frei verfügbar. Der 

g++ unterstützt viele Betriebssysteme (darunter Unix, Linux, Mac OS X, Windows und AmigaOS) und 

Prozessorplattformen. Derzeit dient eine Sonderanfertigung des Compilers namens ConceptGCC als Prüfmittel 

für verschiedene geplante C++-Spracherweiterungen. GNU C++ existiert seit 1987 und ist somit einer der 

ältesten C++-Compiler. [1] 

• Der in Microsoft Visual C++ enthaltene Compiler ist einer der verbreitetsten für das Betriebssystem Windows. 

• Der Comeau C++ ist derzeit der einzige Compiler, der export von Templates integriert hat und damit der 

einzige, der alle C++-Sprachmittel enthält. Das so genannte „Front-End“ des Compilers, also der Teil, der die 

Analyse-Phase implementiert, wurde von der Firma Edison Design Group (EDG) erstellt, die sich auf die 

Entwicklung von Compiler-Front-Ends spezialisiert hat und deren C++-Front-End auch in vielen anderen 

kommerziellen C++-Compilern integriert ist. Der Comeau-Compiler kann auch über das Internet ausprobiert 


• Der Intel C++ Compiler verwendet ebenfalls das erwähnte C++-Front-End von EDG. Der Intel C++ Compiler 

erzeugt Maschinencode für die Intel-Prozessoren unter den Betriebssystemen Windows, Linux und MacOS X. Da 

die mit dem Intel C++ Compiler erzeugten Programme den Befehlssatz der Intel-Prozessoren besonders gut 

ausnutzen, erzeugen sie besonders effiziente Programme für Intel-Prozessoren. 

• Der Borland C++ Builder ist ein im Developer Studio enthaltener C++-Compiler. 

C++-Programmierung 

Das breite Leistungsspektrum und die vielfältigen Gestaltungsmöglichkeiten der Sprache führen zu verhältnismäßig 

langen Einarbeitungszeiten. Außerdem wird die Verwendung von Programmierrichtlinien aus Gründen der 

Wartbarkeit und Fehleridentifizierung mehr als in anderen Sprachen angeraten. Demgegenüber ist der Stand vieler 

Lehrbücher und Lehrveranstaltungen veraltet. Lehrinhalte stimmen oft nicht mit der Realität existierender Compiler 

überein. 

Vergleich mit anderen Sprachen 

Objective-C 

C++ war nicht der einzige Ansatz, die Programmiersprache C um Eigenschaften zu erweitern, die das 

objektorientierte Programmieren vereinfachen. In den 1980er Jahren entstand die Programmiersprache Objective-C, 

die sich aber im Gegensatz zu C++ an Smalltalk und nicht an Simula orientierte. Die Syntax von Objective-C 

unterscheidet sich unter anderem wegen der Smalltalk-Wurzeln stark von C++. Objective-C ist deutlich weniger weit 

verbreitet als C++. Bekannteste Einsatzgebiete von Objective-C sind die Programmierschnittstelle OpenStep und das 

Betriebssystem Mac OS X.

C++ 29 

Java und C# 

[2] [3] 

Die Programmiersprachen Java und C# verfügen über eine ähnliche, ebenfalls an C angelehnte Syntax wie C++, 

sind auch objektorientiert und unterstützen seit einiger Zeit Typparameter, weshalb ein Vergleich mit ihnen 

besonders naheliegend ist. Trotz äußerlicher Ähnlichkeiten unterscheiden sie sich aber konzeptionell von C++, zum 

Teil beträchtlich. 

Generische Techniken ergänzen die objektorientierte Programmierung um Typparameter und erhöhen so die 

Wiederverwertbarkeit einmal kodierter Algorithmen. Die generischen Java-Erweiterungen sind jedoch lediglich auf 

Klassen, nicht aber auf primitive Typen oder Datenkonstanten anwendbar; Abhilfe bietet Java hier allerdings mittels 

sogenannter Wrapper-Klassen, welche für primitive Typen entsprechende Klassen zur Verfügung stellen (z. B. 

Integer als Wrapper für den primitiven Typ int). Demgegenüber beziehen die generischen Spracherweiterungen 

von C# auch die primitiven Typen mit ein. Dabei handelt es sich allerdings um eine Erweiterung für Generik zur 

Laufzeit, die die auf Kompilationszeit zugeschnittenen C++-Templates zwar sinnvoll ergänzen, nicht aber ersetzen 

können. 

Gerade die generische Programmierung macht C++ zu einem mächtigen Programmierwerkzeug. Während die 

objektorientierte Programmierung in Java und C# nach wie vor den zentralen Abstraktionsmechanismus darstellt, ist 

diese Art der Programmierung in C++ rückläufig. So werden tiefe Klassenhierarchien vermieden, und zu Gunsten 

der Effizienz und der Minimierung des Ressourcenverbrauchs verzichtet man in vielen Fällen auf Polymorphie, 

einen der fundamentalen Bestandteile der objektorientierten Programmierung. 

Siehe auch: Simula, Smalltalk 

Entstehung und Weiterentwicklung 

Entstehungsgeschichte 

C++ wurde von Bjarne Stroustrup ab 1979 in den AT&T Bell Laboratories entwickelt. Ausgangspunkt waren 

Untersuchungen des UNIX-Betriebssystemkerns in Bezug auf verteiltes Rechnen. 

Auf die Idee für eine neue Programmiersprache war Stroustrup schon durch Erfahrungen mit der 

Programmiersprache Simula im Rahmen seiner Doktorarbeit an der Cambridge University gekommen. Simula 

erschien zwar geeignet für den Einsatz in großen Software-Projekten, die Struktur der Sprache erschwerte aber die 

für viele praktische Anwendungen erforderliche Erzeugung hocheffizienter Programme. Demgegenüber ließen sich 

effiziente Programme zwar mit der Sprache BCPL schreiben, für große Projekte war BCPL aber wiederum 

ungeeignet. 

Mit den Erfahrungen aus seiner Doktorarbeit erweiterte Stroustrup nun die Programmiersprache C um ein 

Klassenkonzept, für das die Sprache Simula-67 das primäre Vorbild war. Die Wahl fiel auf die Programmiersprache 

C, eine Mehrzwecksprache, die schnellen Code produzierte und einfach auf andere Plattformen zu portieren war. Als 

dem Betriebssystem UNIX beiliegende Sprache hatte C außerdem eine nicht unerhebliche Verbreitung. Zunächst 

fügte er der Sprache Klassen (mit Datenkapselung) hinzu, dann abgeleitete Klassen, ein strengeres Typsystem, 

Inline-Funktionen und Standard-Argumente. 

Während Stroustrup „C with Classes“ („C mit Klassen“) entwickelte (woraus später C++ wurde), schrieb er auch 

cfront, einen Compiler, der aus C with Classes zunächst C-Code als Zwischenresultat erzeugte. Die erste 

kommerzielle Version von cfront erschien im Oktober 1985. 

1983 wurde C with Classes in C++ umbenannt. Erweiterungen darin waren: virtuelle Funktionen, Überladen von 

Funktionsnamen und Operatoren, Referenzen, Konstanten, änderbare Freispeicherverwaltung und eine verbesserte 

Typüberprüfung. Die Möglichkeit von Kommentaren, die an das Zeilenende gebunden sind, wurde wieder aus BCPL 

übernommen (//).

C++ 30 

1985 erschien die erste Version von C++, die eine wichtige Referenzversion darstellte, da die Sprache damals noch 

nicht standardisiert war. 1989 erschien die Version 2.0 von C++. Neu darin waren Mehrfachvererbung, abstrakte 

Klassen, statische Elementfunktionen, konstante Elementfunktionen und die Erweiterung des Schutzmodells um 

protected. 1990 erschien das Buch The Annotated C++ Reference Manual, das als Grundlage für den 

darauffolgenden Standardisierungsprozess diente. 

Relativ spät wurden der Sprache Templates, Ausnahmebehandlung, Namensräume, neuartige Typumwandlungen und 

Boolesche Typen hinzugefügt. 

Im Zuge der Weiterentwicklung der Sprache C++ entstand auch eine gegenüber C erweiterte Standardbibliothek. 

Erste Ergänzung war die Stream-I/O-Bibliothek, die Ersatz für traditionelle C-Funktionen wie zum Beispiel printf() 

und scanf() bietet. Eine der wesentlichen Erweiterungen der Standardbibliothek kam später durch die Integration 

großer Teile der bei Hewlett-Packard entwickelten Standard Template Library (STL) hinzu. 

Nach jahrelanger Arbeit wurde schließlich 1998 die endgültige Fassung der Sprache C++ (ISO/IEC 14882:1998) 

genormt. 2003 wurde ISO/IEC 14882:2003 verabschiedet, eine Nachbesserung der Norm von 1998. 

Die vorhandenen Performance-Probleme der Sprache C++, die Rechenzeit und Speicherplatz betreffen, werden auf 

hohem Niveau zusammen mit Lösungen im Technical Report ISO/IEC TR 18015:2006 diskutiert. Das Dokument ist 

zum Download von ISO freigegeben. 

Der Name „C++“ 

Der Name ist eine Wortschöpfung von Rick Mascitti und wurde zum ersten Mal im Dezember 1983 benutzt. Der 

Name kommt von der Verbindung der Vorgängersprache C und dem Inkrement-Operator „++“, der den Wert einer 

Variablen inkrementiert (auf den nächsten Wert erhöht). 

Weiterentwicklung der Programmiersprache C++ 

Um mit den aktuellen Entwicklungen der sich schnell verändernden Computer-Technik Schritt zu halten, aber auch 

zur Ausbesserung bekannter Schwächen, erarbeitet das C++-Standardisierungskomitee derzeit die nächste größere 

Revision von C++, die inoffiziell mit C++0x abgekürzt wird, worin die Ziffernfolge eine grobe Einschätzung des 

möglichen Erscheinungstermins andeuten soll. Im November 2006 wurde der Zieltermin für die Fertigstellung auf 

das Jahr 2009 festgelegt und die Abkürzung C++09 dafür eingeführt. Im Juli 2009 wurde dieser Termin auf 

frühestens 2010 geändert. 

Die vorrangigen Ziele für die Weiterentwicklung von C++ sind Verbesserungen im Hinblick auf die 

Systemprogrammierung sowie zur Erstellung von Programmbibliotheken. Außerdem soll die Erlernbarkeit der 

Sprache für Anfänger verbessert werden. 

Berücksichtigung aktueller technischer Gegebenheiten 

C++ deckt einige typische Problemfelder der Programmierung noch nicht ausreichend ab, zum Beispiel die 

Unterstützung von Nebenläufigkeit (Threads), deren Integration in C++, insbesondere für die Verwendung in 

Mehrprozessorumgebungen, eine Überarbeitung der Sprache unumgänglich macht. Durch ein überarbeitetes 

Speichermodell sollen Garantien der Sprache für den nebenläufigen Betrieb festgelegt werden, um Mehrdeutigkeiten 

in der Abarbeitungsreihenfolge sowohl aufzulösen als auch in bestimmten Fällen aufrechtzuerhalten und dadurch 

Spielraum für Optimierungen zu schaffen. Eine eigene Bibliothek zur Unterstützung von Threads durch die 

C++09-Standardbibliothek wird ebenfalls durch den neuen Sprachstandard eingeführt.

C++ 31 

Verbesserungen am Sprachkern 

Zu den weitreichenderen Spracherweiterungen gehört die Typinferenz zur Ableitung von Ergebnistypen aus 

Ausdrücken und die R-Wert-Referenzen, mit deren Hilfe sich als Ergänzung zu dem bereits vorhandenen Kopieren 

von Objekten dann auch ein Verschieben realisieren lässt. 

Erweiterung der Programmbibliothek 

Im April 2006 gab das C++-Standardisierungskomitee den so genannten ersten technischen Report (TR1) heraus, 

eine nichtnormative Ergänzung zur aktuell gültigen, 1998 definierten Bibliothek, mit der Erweiterungsvorschläge 

vor einer möglichen Übernahme in die C++-Standardbibliothek auf ihre Praxistauglichkeit hin untersucht werden 

sollen. Viele Compiler-Hersteller liefern den TR1 mit ihren Produkten aus. 

Enthalten sind im TR1 u. a. reguläre Ausdrücke, [4] verschiedene intelligente Zeiger, [5] ungeordnete assoziative 

Container, [6] eine Zufallszahlenbibliothek, [7] Hilfsmittel für die C++-Metaprogrammierung, Tupel [8] sowie 

numerische und mathematische Bibliotheken. [9] Die meisten dieser Erweiterungen stammen aus der 

Boost-Bibliothek, woraus sie mit minimalen Änderungen übernommen wurden. Außerdem sind sämtliche 

Bibliothekserweiterungen der 1999 überarbeiteten Programmiersprache C (C99) in einer an C++ angepassten Form 

enthalten. [10] 

Mit Ausnahme der numerischen und mathematischen Bibliotheken wurde die Übernahme aller TR1-Erweiterungen 

in die kommende Sprachnorm C++0x bereits vom C++-Standardisierungskomitee beschlossen. 

Siehe auch 

• C++-Standardbibliothek 

• Ressourcenbelegung ist Initialisierung (RAII) 

• C++/CLI 

• Embedded C++, eine Variante der Sprache C++ für eingebettete Systeme. 

Literatur 

• Bjarne Stroustrup: Die C++-Programmiersprache. 4. Auflage. Addison-Wesley, 2009, ISBN 978-3-8273-2823-6 

(Standardwerk zu C++, Grundkenntnisse in C von Vorteil.). 

• Bjarne Stroustrup: The Design and Evolution of C++. Addison-Wesley, 1994, ISBN 978-0201543308 (Das Buch 

beschreibt die Entwicklung und Design von C++; Vom Sprachdesigner geschrieben.). 

• Bjarne Stroustrup: Programming -- Principles and Practice Using C++.. Addison-Wesley, 2008, ISBN 

978-0321543721 (Einführung in die Programmierung; Standardwerk für Texas A&M 

Einstiegsprogrammierkurse). 

• Andrew Koenig, Barbara E. Moo: Intensivkurs C++. 1. Auflage. Pearson Studium, 2003, ISBN 3-8273-7029-9 

(Vergriffen, Anfängerbuch, ein gewisses Grundverständnis der Programmierung ist von Vorteil.). 

• Scott Meyers: Effektiv C++ Programmieren – 55 Möglichkeiten, Ihre Programme und Entwürfe zu verbessern. 

1. Auflage. Addison-Wesley, 2006, ISBN 3-8273-2297-9 (Zur Vertiefung bereits vorhandener C++-Kenntnisse.). 

• Scott Meyers: Mehr Effektiv C++ programmieren – 35 neue Wege zur Verbesserung Ihrer Programme und 

Entwürfe. 1. Auflage. Addison-Wesley, 1997, ISBN 3-8273-1275-2 (Vertiefung vorhandener C++-Kenntnisse.). 

• Herb Sutter: Exceptional C++. 1. Auflage. Addison-Wesley, 2000, ISBN 3-8273-1711-8 (Vertiefung 

vorhandener C++-Kenntnisse.). 

• Andrei Alexandrescu: Modernes C++ Design – Generische Programmierung und Entwurfsmuster angewendet. 

1. Auflage. Mitp-Verlag, 2003, ISBN 3-8266-1347-3 (Ein Standardwerk zur C++-Metaprogrammierung, setzt ein 

tiefes Verständnis von C++ voraus.).

C++ 32 

• Bruce Eckel: Thinking in C++, Volume 1: Introduction to Standard C++. 2. Auflage. Prentice Hall, 2000, ISBN 

0-13-979809-9 (Online [11] ). 

• Bruce Eckel: Thinking in C++, Volume 2: Practical Programming. 1. Auflage. Prentice Hall, 2003, ISBN 

0-13-035313-2 (Online [11] ). 

• Herbert Schildt: Learn C++ from the Ground Up. 3. Auflage. McGraw Hill - Osborne, 2003, ISBN 

978-0-0722-2897-7. 

Weblinks 

• Webauftritt des C++-Standardisierungskomitees [12] , englisch 

• Bjarne Stroustrup über die Geschichte von C++ zwischen 1991 und 2006 (HOPL-III) [13] , englisch 

• Links zum Thema C++ [14] im Open Directory Project 

Referenzen 

[1] Bjarne Stroustrup: Evolving a language in and for the real world: C++ 1991-2006 (http:/ / www. cs. tamu. edu/ news/ items?id=1797) 

[2] Java - A Bit of History (http:/ / java. sun. com/ docs/ books/ jvms/ second_edition/ html/ Introduction. doc. html) 

[3] Peter Drayton, Ted Neward, Ben Albahari: C# in a Nutshell: A Desktop Quick Reference. 2. Auflage. O'Reilly, 2003, ISBN 

978-0-5960-0526-9. 

[4] regex_proposal (http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ papers/ 2003/ n1429. htm) 

[5] A Proposal to Add General Purpose Smart Pointers to the Library Technical Report (http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ 

papers/ 2003/ n1450. html) 

[6] A Proposal to Add Hash Tables to the Standard Library (http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ papers/ 2003/ n1456. html) 

[7] A Proposal to Add an Extensible Random Number Facility to the Standard Library (Revision 2) (http:/ / www. open-std. org/ jtc1/ sc22/ 

wg21/ docs/ papers/ 2003/ n1452. html) 

[8] http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ papers/ 2002/ n1403. pdf 

[9] C++ Mathematical Special Functions Proposal (http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ papers/ 2003/ n1422. html) 

[10] ISO/IEC JTC1/SC22/WG21 N1568 (http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ docs/ papers/ 2004/ n1568. htm) 

[11] http:/ / jamesthornton. com/ eckel/ 

[12] http:/ / www. open-std. org/ jtc1/ sc22/ wg21/ 

[13] http:/ / www. cs. tamu. edu/ news/ items?id=1797 

[14] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ C+ + /

C-Sharp 33 

C- Sharp 

Der korrekte Titel dieses Artikels lautet „C#“. Diese Schreibweise ist aufgrund technischer Einschränkungen nicht 

möglich. 

Falsche Vorlage! 

Bitte ersetze durch 

Paradigmen: strukturiert, imperativ, objektorientiert, funktional 


Entwickler: Microsoft 

Aktuelle Version: 3.0 (2009) 

Typisierung: statisch, stark 

Einflüsse: C, C++, Delphi, SQL, Java, Modula-3, Visual Basic 

Beeinflusste: 

Java [1] 

. 

C# 

Betriebssystem: alle, für die eine CLI-Implementierung existiert (z. B. Microsofts CLR des .NET-Frameworks oder Novells 

Mono) 

C# (lies engl. c sharp, englische Aussprache [ˌsiːˈʃɑːp]) ist eine vom Softwarehersteller Microsoft im Rahmen seiner 

.NET-Strategie entwickelte Programmiersprache. C# ist bei ECMA [2] und ISO als Standard registriert. 

Die aktuelle Version von C# ist 3.0, welche im Jahr 2007 gleichzeitig mit dem .NET Framework 3.5 verabschiedet 

wurde. Die nächste Version 4.0 ist aktuell in Entwicklung. 

Konzept 

C# greift Konzepte der Programmiersprachen Java, C++, SQL, C sowie Delphi auf. C# zählt zu den 

objektorientierten Programmiersprachen und unterstützt sowohl die Entwicklung von sprachunabhängigen 

.NET-Komponenten als auch COM-Komponenten für den Gebrauch mit Win32-Applikationen. 

Einige der Elemente von C++, die im Allgemeinen als unsicher gelten, wie beispielsweise Zeiger, werden in C# nur 

für sogenannten „unsicheren Code“ erlaubt, der in Zonen mit eingeschränkten Rechten (z. B. bei Programmen, die 

aus Webseiten heraus ausgeführt werden) ohne die Zuteilung erweiterter Rechte nicht ausgeführt wird. 

Als .NET-Sprache verfügt auch C# über Sprachunterstützung für Attribute und Delegaten. Attribute erlauben es, 

Informationen über eine Klasse, ein Objekt, oder eine Methode zu speichern, die zur Laufzeit ausgewertet werden 

können. Man spricht hierbei auch von Metadaten. Ein Delegat kann auf Methoden einer Klasse verweisen. Das 

Konzept lässt sich mit Funktionszeigern vergleichen. Im Unterschied zu diesen enthalten Delegaten zusätzlich auch 

Verweise auf die zu den Methoden gehörenden Objekte. Ein Aufruf eines Delegaten ruft also Methoden auf, denen 

implizit ein Objektzeiger als Parameter übergeben wird. Außerdem müssen Delegaten typensicher deklariert werden, 

was zur Folge hat, dass Inkompatibilitäten der Methodensignaturen zwischen aufrufendem Delegat und der 

aufzurufenden Methode schon während der Compilierung aufgelöst werden. 

Ab der Version 2.0 von C#, das mit .NET-Framework 2.0 freigegeben wurde, unterstützt C# neben generischen 

Typen (engl. generics) auch anonyme Methoden, Generatoren und partielle Klassen. Generische Typen, Iteratoren 

und partielle Klassen sind Bestandteil des .NET-Frameworks 2.0 und stehen somit auch anderen 

.NET-Programmiersprachen wie beispielsweise VB.NET zur Verfügung.

C-Sharp 34 

Standardisierung 

Microsoft reichte im August 2000 zusammen mit Hewlett-Packard und der Intel Corporation C# bei der 

Normungsorganisation Ecma International zur Normung ein. Im Dezember 2001 veröffentlichte die ECMA die 

Norm ECMA-334 C# Language Specification. 2003 wurde C# von der ISO genormt (ISO/IEC 23270). 

Im Juni 2005 genehmigte die ECMA die dritte Version (C# 2.0) der C#-Spezifikationen und aktualisierte die 

bisherige Norm ECMA-334. Hinzu kamen die partiellen Klassen, anonyme Methoden, nullable types und Generics, 

die Ähnlichkeiten zu den C++-Templates aufweisen. Im Juli 2005 übergab die ECMA die Standards und 

zugehörigen TRs an die ISO/IEC JTC 1. 

Die ECMA-Spezifikation 334 deckt nur die Sprache C# ab. Programme, die in C# geschrieben werden, nutzen 

gewöhnlich das .NET-Framework, welches teilweise durch andere Spezifikationen beschrieben wird und teilweise 

proprietär ist. Dennoch ist die Sprache C# prinzipiell plattformunabhängig. Das von Ximian (jetzt Novell) initiierte 

Projekt Mono ermöglicht beispielsweise auch Linuxnutzern, C# für Entwicklungen auf ihrem Betriebssystem 

einzusetzen. 

Microsoft veröffentlichte die dritte Version von C# mit dem .NET-SDK 2.0 und Visual Studio 2005 im November 

2005. 

Microsoft stellte klar, dass C#, genauso wie andere .NET-Sprachen, einen wichtigen Bestandteil seiner 

Softwarestrategie sowohl für den internen als auch für den externen Gebrauch darstelle. Das Unternehmen 

übernimmt eine aktive Rolle in der Vermarktung der Sprache als Teil seiner gesamten Geschäftsstrategie. 

Verfügbarkeit von integrierten Entwicklungsumgebungen 

Neben der von Microsoft vertriebenen Entwicklungsplattform Microsoft Visual Studio aus dem eigenen Hause gibt 

es inzwischen auch Entwicklungsumgebungen (IDEs) anderer Hersteller für C#: 

• SharpDevelop – (Open-Source) 

• MonoDevelop – IDE für Windows und Unix-basierte Betriebssysteme (Open-Source) 

• Visual C# Express (Eingeschränkte kostenlose Version von Microsoft Visual Studio) 

• XNA Game Studio – IDE von Microsoft zur Spieleentwicklung 

• C#-Builder von Borland (Verwendet den Microsoft C#-Compiler in Lizenz) 

• Baltie, C#-IDE für Kinder. 

Compiler 

→ Hauptartikel Common Language Infrastructure 

• Das OpenSource-Projekt dotGNU entwickelt eine freie .NET-Version inklusive C#-Compiler und beherrscht 

Windows.Forms 

• Das OpenSource-Projekt mono entwickelt eine freie und plattformunabhängige .NET-Version inklusive 

C#-Compiler

C-Sharp 35 

Der Name C# 

C♯ ist ursprünglich ein Symbol für den in der Musik durch ein Kreuz (♯) um einen Halbton erhöhten Ton C, das Cis 

– englisch C sharp. [3] Da das Kreuz allerdings auf keiner Standardtastatur direkt eingegeben werden kann, wird bei 

der Schreibung des Namens in der Regel das typographisch ähnliche Rautenzeichen # als Ersatzdarstellung 

gewählt. [4] 

Sprachelemente von C# 

→ Hauptartikel Sprachelemente von C# 

Das folgende typische Hallo-Welt-Programm soll als C#-Syntaxbeispiel für ein einfaches Konsolen-Programm 

dienen: 

class Program 

{ 

} 

public static void Main() 

{ 

} 

System.Console.WriteLine("Hallo Welt!"); 

Mit LINQ können Datenbankabfragen direkt im Quelltext eingebunden werden. 

Sprachderivate 

• Spec# 

• Sing# 

• Cω 

• eXtensible C# (XC#) 

• Multiprocessor C# (MC#) 

• Metaphor 

• Polyphonic C# 

• Vala für Programme des GNOME-Projektes 

Literatur 

• Frank Eller: Visual C# 2008. Addison-Wesley 2008, ISBN 978-3-8273-2641-6. 

• Golo Roden: Auf der Fährte von C#. Springer-Verlag, 2008, ISBN 978-3-540-27888-7 (Volltext online unter 

guide to C# [5] ). 

• Andreas Kühnel: Visual C# [6] . Galileo Computing, 2008, ISBN 978-3-8362-1172-7 (Volltext online). 

• Daniel Moses, Johannes Nowak: C# Programmieren unter .NET. Franzis’ Verlag GmbH, 2002, ISBN 

3-7723-7224-4. 

• Dirk Louis, Shinja Strasser: Microsoft Visual C# 2008 - Das Entwicklerbuch. Microsoft Press, 2008, ISBN 

978-3-86645-507-8. 

• Klaus Fahnenstich, Rainer G. Haselier: Richtig einsteigen: Programmieren lernen mit Visual C# 2008. Microsoft 

Press, ISBN 978-3-86645-207-7. 

• Jürgen Bayer: C# Codebook. Addison-Wesley Verlag, 2009, ISBN 3-8273-2576-5

C-Sharp 36 

Weblinks 

• Links zum Thema C-Sharp [7] im Open Directory Project 

Referenzen 

[1] Java 5 catches up with C# (http:/ / www. barrycornelius. com/ papers/ java5/ onefile/ ) 

[2] ECMA-Spezifikation der Sprache (http:/ / www. ecma-international. org/ publications/ standards/ Ecma-334. htm) 

[3] Töne der C-Dur-Tonleiter (http:/ / www. helmut-eisel. de/ wsmaterial/ C-Dur. pdf) (PDF) 

[4] Vorwort des Buches C# mit Methode, Christian Bleske (Hrsg.), Alexander Mayer, Michael Fischer, Michael Starke, Michael Steil ( PDF 

(http:/ / www. cul. de/ data/ csharppr2. pdf)) 

[5] http:/ / www. guidetocsharp. de 

[6] http:/ / www. galileocomputing. de/ openbook/ visual_csharp/ index. htm 

[7] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ C-Sharp/ 

COBOL 

COBOL 

Paradigmen: Zunächst rein imperativ, später erweitert um Elemente der strukturierten, prozeduralen und heutzutage 

sogar objektorientierten Programmierung 


Entwickler: Grace Hopper, William Selden, Gertrude Tierney, Howard Bromberg, Howard Discount, Vernon Reeves, 

Jean E. Sammet 

Aktuelle Version: COBOL 2002 (2002) 


wichtige 

Implementierungen: 

Open COBOL [1] , und viele andere 

Dialekte: DEC COBOL, HP COBOL, IBM OS/VS COBOL, IBM COBOL/II, IBM COBOL SAA, IBM Enterprise 

COBOL, IBM COBOL/400, IBM ILE COBOL, Unix COBOL X/Open, Micro Focus COBOL, Microsoft 

COBOL, Ryan McFarland RM/COBOL, Ryan McFarland RM/COBOL-85, DOSVS COBOL, UNIVAC 

COBOL, Realia COBOL, Fujitsu COBOL, ACUCOBOL-GT 

Einflüsse: FLOW-MATIC, COMTRAN 

Beeinflusste: PL/I, PL/SQL, ABAP 

Betriebssystem: z/OS, Windows, Linux, Mac OS X, BS2000, OS/400 uvm. 

COBOL ist eine Programmiersprache, die wie FORTRAN in der Frühzeit der Computerentwicklung 1960 

entstanden ist und bis heute verwendet wird. Der Stil dieser Programmiersprache ist wortreich und stark an die 

natürliche Sprache angelehnt. 

Die Abkürzung COBOL steht für „Common Business Oriented Language“. 

Geschichte 

COBOL entstand aus dem dringenden Wunsch, eine hardware-unabhängige standardisierte problemorientierte 

Sprache für die Erstellung von Programmen für den betriebswirtschaftlichen Bereich zu haben. Die Programmierung 

kaufmännischer Anwendungen unterscheidet sich von technisch-wissenschaftlichen Anwendungen durch die 

Handhabung großer Datenmengen statt der Ausführung umfangreicher Berechnungen. Nachdem die 

Programmierung technisch-wissenschaftlicher Anwendungen durch FORTRAN bereits stark vereinfacht worden 

war, sollte die neue Programmiersprache durch verstärkte Berücksichtigung kommerzieller Problemstellungen,

COBOL 37 

insbesondere der Handhabung großer Datenmengen und ihrer Ein- und Ausgabe, dies auch für kommerzielle 

Anwendungen erreichen, die bis dahin weitgehend in Assemblersprachen programmiert wurden. Eine vom 

amerikanischen Verteidigungsministerium eingesetzte Arbeitsgruppe entwickelte einen Standard aus der 

Vermählung der damaligen Programmiersprachen FLOW-MATIC von Sperry Univac (Remington-Rand), 

Commercial Translator (COMTRAN) von IBM und FACT von Minneapolis-Honeywell. Namentlich beteiligt hieran 

war Grace M. Hopper. 

Das Ergebnis wurde 1960 als COBOL-60 von CODASYL verabschiedet, in der Folgezeit weiterentwickelt und von 

nationalen und internationalen Normierungsinstituten (ANSI, ISO) standardisiert. 

COBOL fand schnell den Weg in die zivile Nutzung als eine der ersten kommerziell eingesetzten kompilierbaren 

und bis heute am weitesten verbreiteten Programmiersprachen, vor allem für kommerzielle Anwendungen. 

Sprachsyntax 

Ursprünglich wurde COBOL nur in Großbuchstaben geschrieben (man hatte nur Lochkarten und Zeilendrucker ohne 

Kleinbuchstaben). Auch heute wird nicht zwischen Groß- und Kleinschreibung unterschieden (COBOL ist somit 

nicht case sensitive). 

Ein COBOL-Programm ist in Teile (DIVISION), Kapitel (SECTION) und Abschnitte (PARAGRAPH) gegliedert. 

Die vier DIVISIONs sind in ihrer festgelegten Reihenfolge: 

• Identification Division mit dem Programmnamen und einigen weitgehend obsoleten Paragraphen für 

Kommentare; 

• Environment Division, wo Schnittstellen zum Betriebs- und dessen Dateisystem definiert werden; 

• Data Division mit der Definition der Programmvariablen und Datenstrukturen und 

• Procedure Division mit den prozeduralen Anweisungen. 

In der IDENTIFICATION DIVISION gibt es keine SECTIONs, und in der PROCEDURE DIVISION können 

neuerdings SECTIONs und auch PARAGRAPHs entfallen. ENVIRONMENT und DATA DIVISIONs können unter 

Umständen ganz entfallen. 

Hieran sieht man die strikte Trennung von Datendeklaration und prozeduralen Anweisungen, durch die sich COBOL 

auszeichnet. Im Prozedurteil kann man nur Variablen benutzen, die vorher im Datenteil deklariert worden sind. Auch 

das Aussehen von formatierten Ausgaben wird nicht im Prozedurteil, sondern im Datenteil durch die 

PICTURE-Klausel festgelegt. Der „REPORT WRITER“ macht es möglich, die Struktur einer Druckliste komplett im 

Datenteil als physische Struktur von Seiten und logische Struktur von Postenzeilen mit Gruppensummen etc. zu 

beschreiben, ohne dass sich der Prozedurteil darum kümmern muss. 

Kodierung 

Das traditionelle Kodierschema bei Cobol entspricht der Lochkarte mit ihren 80 Spalten, d. h. Schreibstellen. Dabei 

waren die ersten 6 Stellen für die Zeilennummerierungen reserviert. Spalte 7 wurde zur Kennzeichnung einer 

Kommentar- oder einer Fortsetzungszeile beziehungsweise einer, die nur für das Debugging übersetzt werden soll, 

reserviert. Spalte 8 bis 11 (Area A) beinhaltete die Namen von Divisions, Sections und Paragraphs. Die 12. bis 72. 

Spalte (Area B) beherbergten alles übrige, zum Beispiel Anweisungen (statements). Spalte 73 bis 80 waren für 

sonstige Markierungen wie z. B. den Namen des Programms oder Quelltext-Elementen vorgesehen. 

Der aktuelle Standard (2002) kennt ein fixes Zeilenformat, das die Einteilung in Area A und Area B aufhebt, sowie 

ein ganz freies Format, das in den Spalten 1 bis 255 alles erlaubt. Die Sonderrolle der Spalte 7 entfällt da 

Kommentare mit *> eingeleitet, Fortsetzungszeilen mittels & zusammengesetzt und Debuggingzeilen mittels 

bedingter Übersetzung realisiert werden (>>DEFINE … >>IF …). 

Ein fast minimales Cobol-Programm: Identification Division. Program-ID. HALLOPGM. Procedure Division. 

Display "Hallo Wikipedianer!" STOP RUN.

COBOL 38 

Datendeklarationen 

… erfolgen in der Data Division 

• Dateien und deren Satzstrukturen werden in der File Section beschrieben. 

• Statische (globale) Variablen werden in der Working-Storage Section definiert. 

• Automatische (lokale bzw. dynamische) Variablen werden in der Local-Storage Section definiert. (siehe Stack) 

• Aufruf-Parameter werden in der Linkage Section definiert. 

• Komplexe Drucklisten werden in der Report Section definiert. 

• Bildschirmein- und ausgabe in der Screen Section. 

Zur Deklaration von Variablen bietet COBOL zahlreiche Klauseln, deren wichtigsten die Stufennummer, die 

PICTURE-Klausel und die USAGE-Klausel sind. 

Die Stufennummer 77 kennzeichnet eine freistehende Variable, 01 kann ebenfalls eine freistehende Variable 

bezeichnen, leitet aber normalerweise die Deklaration einer Gruppe ein, was in anderen Sprachen als Record (Pascal 

u. ä.) oder struct (C++, C u. ä.) bezeichnet wird. Die Stufennummern 02 bis 49 kennzeichnen dann dieser Gruppe 

untergeordnete Datendeklarationen, die selber auch wieder Gruppen (Records) sein können. Eine Datendeklaration, 

die keine weiteren untergeordneten (mit höheren Stufennummern) Datendeklarationen hat, wird in COBOL als 

elementar (elementary Item) bezeichnet, ansonsten ist es eine Gruppen-Variable (Group Item). Eine solche Gruppe 

kann man abstrakt als Baum darstellen mit den Gruppen als Knoten und den elementary Items als Blättern. 

Mit der speziellen Stufennummer 66 kann man ganzen Speicherbereichen einen anderen Namen geben, mit 88 einen 

Bedingungsnamen definieren, der wie ein boolescher Ausdruck in zum Beispiel einer IF-Anweisung verwandt 

werden kann. 

Die Stufennummern werden üblicherweise zweistellig geschrieben. Aus den Lochkartenzeiten stammt die 

Gewohnheit, die Stufennummern in einer Gruppendefinition nicht fortlaufend, sondern in Schritten von 5 oder 10 zu 

vergeben, weil man dann Zwischenstufen einfügen konnte, ohne gleich einen ganzen Kartenstapel neu lochen zu 

müssen. 

Das folgende Beispiel beschreibt das Layout der traditionellen 80-stelligen COBOL-Programmzeile: 

01 Cobol-Zeile USAGE DISPLAY. 

05 Zeilennummer PIC 9(6). 

05 Indikator PIC X. 

88 Ist-Kommentar VALUES '*' '/'. 

88 Ist-Fortsetzungszeile VALUE '-'. 

88 Ist-Debuggingzeile VALUE 'D' 'd'. 

05 Bereich-A-und-B. 

10 Bereich-A PIC X(4). 

10 Bereich-B PIC X(61). 

05 Zeilen-Endekennung PIC X(8). 

Die Definition eines Wertebereiches sieht als Beispiel so aus: 

01 Wertebereich PIC 99V99 USAGE COMPutational. 

88 Einerwerte Value 1 thru 9. 

88 Zehnerwerte Value 10 thru 19. 

88 Zwanzigerwerte Value 20 thru 29. 

Äußere Erscheinung und interne Repräsentation werden im wesentlichen durch die Klauseln PICTURE und USAGE 

bestimmt. USAGE COMP, wenn damit binär gerechnet werden soll, DISPLAY zur Anzeige. Der Standard ist 

hingegen, dezimal zu rechnen. Die Symbole hinter PICture legen die Anzahl Stellen oder Zeichen fest, bzw. 

Editiersymbole wie Dezimal- oder Tausendertrennzeichen, Vorzeichen, Währungssymbole, gedachtes

COBOL 39 

Dezimaltrennzeichen (V) etc., und bestimmen eine elementare Variable damit als entweder alphabetisch, 

alphanumerisch, numerisch oder numerisch-editiert. 

In COBOL wird die Formatierung für sichtbare Ausgabe eben durch die Datendeklaration erledigt, nicht durch 

prozedurale Anweisungen wie in Sprachen wie Pascal oder C. Den Rest der insgesamt etwa 60 möglichen Klauseln 

einer Datendeklaration möge man in einem COBOL-Handbuch nachschlagen. 

Prozedurale Anweisungen 

In der Procedure Division findet sich der ausführbare Programmcode. Die Ausführung beginnt mit der ersten 

Anweisung hinter der Überschrift Procedure Division bzw. den DECLARATIVES, deren Ausführung nur durch 

bestimmte Ereignisse ausgelöst wird. Danach werden alle Anweisungen sequentiell ausgeführt, bis ein STOP RUN 

das Programm beendet, oder ein GO TO zu einer anderen Stelle im Programm verzweigt. 

Die Procedure Division besteht aus einer oder mehreren Prozeduren. Eine Prozedur ist entweder 

• eine Section: Ein Name, der in Spalte 8 beginnt gefolgt von dem Schlüsselwort SECTION und einem Punkt. 

• eine Gruppe von Sections 

• ein Paragraph: Ein Name, der in Spalte 8 beginnt und mit Punkt endet. 

• eine Gruppe von Paragraphs 

Eine solche Prozedur besteht dann aus einem oder mehreren Cobol-Anweisungen (Statements). 

Prozeduren können mit der Cobol-Anweisung Perform ausgeführt werden. Es gibt keine formale 

Parameterübergabe, alle Prozeduren haben Zugriff auf alle Felder in der Data Division. 

Mittels CALL können externe Programme (Cobol oder andere Programmiersprachen) aufgerufen werden. Dabei 

werden Parameter By Reference oder By Content übergeben, wodurch unterschieden wird, ob das aufgerufene 

Programm übergebene Variablen im aufrufenden Programm ändern kann. 

Cobol unterstützt (wenn auch mühselig) die strukturierte Programmierung; die Verwendung des ebenfalls zulässigen 

GOTOs ist heute verpönt. In der professionellen Programmierung herrschen hausinterne Programmierstandards, 

welche in der Mehrzahl festlegen, dass Prozeduren ausschließlich aus einer Section bestehen. 

Ziel der Cobol-Syntax soll sein, dass auch ein nicht an formale Programmiersyntax gewohnter Mensch den Sinn 

eines Cobol-Programm erahnen kann (wenn er oder sie etwas Englisch kann). Alle Cobol-Anweisungen beginnen 

mit einem Verb, und davon gibt es viele. 

Einfache Codeschnipsel 

Zur Darstellung der Syntax wird einfaches C (oder Java) zu Hilfe genommen. 

• Ein a = b; ist in Cobol MOVE b TO a. 

• Wenn es zum Beispiel in C heißt a = b + c;, dann schreibt ein Cobol-Programmierer entweder ADD b TO c 

GIVING a oder alternativ COMPUTE a = b + c. 

• Ein a++; in C entspricht auf Cobol ADD 1 TO a.

COBOL 40 

IF/ELSE und EVALUATE 

IF und ELSE funktionieren so, wie man es erwartet. Das End-If wurde erst mit dem COBOL85-Standard eingeführt. 

Im COBOL74-Standard wurde die IF-Anweisung noch durch einen Punkt beendet, was eine leicht zu übersehende 

Fehlerquelle darstellen konnte. 

COBOL85-Syntax: 

If Nenner > 0 

Else 

End-If 


Compute Zahl = Zaehler / Nenner 

End-Compute 

Display "Ich bin so unglücklich!" 

Move 0 To Zahl 

If Nenner > 0 

Else 


Display "Ich bin so unglücklich!" 

Move 0 To Zahl. 

EVALUATE macht die mehrfache Fallunterscheidung, womit jede Form von CASE oder Switch (wie in C), Folgen 

von IF/ELSIF/ELSIF/END-IF bis hin zu vollständigen Entscheidungstabellen dargestellt werden kann. Die 

Anweisung EVALUATE wurde erstmals in COBOL85 integriert, COBOL-Versionen vor der 85-Version kennen 

kein EVALUATE, so dass dort mehrfache Fallunterscheidungen über – teils schwierig zu lesende – IF-Konstrukte 

abgebildet werden mussten. 

Evaluate True 

When Nenner > 0 


When Nenner < 0 

When Other 

End-Evaluate 

Compute Zahl = Zaehler / Nenner * -1 

Display "Ich bin schon wieder unglücklich!" 

Move 0 To Zaehler 

Eine Cobol-Spezialität sind die sogenannten Conditional Statements, das sind Cobol-Anweisungen mit einer 

Bedingungs-Klausel: 


Read Eingabesatz 

At End 

End-read 

Display "Dateiende erreicht" Eingabe-Zaehler "gelesen!" 

Set Ende-der-Verarbeitung To True 

Not At End 

Add 1 to Eingabe-Zaehler

COBOL 41 

Schleifen 

Eine C-Schleife wie „for (i=0; i= 10 

Das Haupteinsatzgebiet der Programmiersprache COBOL ist die betriebswirtschaftliche Datenverarbeitung. Wenn 

EDV-Programme in eine Benutzerschnittstelle, einen Verarbeitungsteil und einen Datenhaltungsteil strukturiert 

werden, liegt der Einsatzschwerpunkt von COBOL-Programmen im Verarbeitungsteil. 

Insbesondere auf PCs, aber auch auf anderen Systemen können als Benutzerschnittstelle eine Vielzahl von 

Möglichkeiten zum Einsatz kommen. Neben den Standard-COBOL Anweisungen ACCEPT zur Tastatureingabe und 

DISPLAY zur Bildschirmausgabe kommt aus der X/OPEN-Spezifikation die SCREEN SECTION hinzu, außerdem 

herstellerspezifische Lösungen. 

Sofern die Anwendungsarchitektur in mehrere Schichten getrennt ist, kann die Präsentationsschicht auch auf den 

Client verlagert werden. Dies erlaubt den Zugriff auf COBOL-Anwendungen über grafische Frontends. Client und 

Server müssen dazu ein Kommunikationsprotokoll unterstützen. Momentan erlebt die Serviceorientierte Architektur 

(SOA) einen Hype, die unter anderem dieses Problem durch einen Standard zu lösen sucht. 

Der Datenhaltungsteil kann mit COBOL-Mitteln oder mit einem Datenbankanschluss realisiert werden. Für den 

Zugriff auf relationale Datenbanken stellt COBOL embedded SQL (EXEC SQL) zur Verfügung. Auch kann man 

Stored Procedures in Cobol programmieren. 

COBOL ist in der Wirtschaft und Verwaltung, z. B. bei den Finanzbehörden, weit verbreitet. Aufgrund der historisch 

gewachsenen Anzahl an COBOL-Programmen ist es für die Unternehmen sehr schwer und sehr teuer, diese zu 

ersetzen. Mangelnde Dokumentation ist hier jedoch als Hauptgrund zu nennen (Softwarekrise), nicht jedoch die 

Unersetzlichkeit von COBOL. 

Neuerungen in COBOL aus der jüngsten Zeit: 

• Nested Program erlaubt es, innerhalb eines COBOL-Programms Prozeduren mit lokalen Variablen zu schreiben. 

• Intrinsic Functions für mathematische und andere Funktionen. 

• Rekursion bei externen Aufrufen (call) ist möglich. 

• Das COBOL-Verb XML PARSE bietet einen integrierten XML-Parser. 

• OO-Erweiterungen erleichterten die Zusammenarbeit mit objektorientierten Programmiersprachen. 

• Formatfreie Notation erlaubt eine Zeilenlänge von 255 Zeichen und ein Verzicht auf die alten Margins A und B. 

• Bedingte Compilierung und ein preprocessing. 

Entwicklung und Standardisierung 

Ein Ausschuss des oben erwähnten CODASYL erarbeitete im Jahr 1959 einige Grundsätze, legte den Namen 

COBOL fest und veröffentlichte im April 1960 seinen Abschlussbericht mit den ersten Spezifikationen der 

Programmiersprache, die als COBOL-60 in die Geschichte eingingen. 

Im Rahmen von CODASYL gab es dann ständig einen Ausschuss, teilweise mit Unterausschüssen, der bzw. die sich 

mit der Weiterentwicklung von COBOL befassten und im Lauf der Jahrzehnte verschiedene Namen und 

verschiedene Status innerhalb von CODASYL hatten.

COBOL 42 

Entwicklung durch CODASYL 

COBOL-60 zeigte die Praktikabilität der angestrebten gemeinsamen Programmiersprache. 

COBOL-61 war nur teilweise kompatibel mit der Vorgängerversion, wurde aber weitgehend in zahlreichen 

Compilern implementiert. CODASYL hat sich dann darauf verpflichtet, die Sprache von da aus evolutionär 

weiterzuentwickeln, statt revolutionäre Änderungen vorzunehmen. 

Mit COBOL-61 EXTENDED kamen u. a. die SORT-Möglichkeiten und der REPORT WRITER hinzu. 

COBOL, EDITION 1965 fügte u. a. interne Tabellen und Optionen für Dateibearbeitung hinzu. 

Weitere Dokumente zur Entwicklung sind die CODASYL COBOL JOURNAL OF DEVELOPMENT der Jahre 

1968, 1969, 1970, 1973, 1976, 1978, 1981 und 1984. 

Erweiterungen durch X/Open, die Open Group 

Im Rahmen der Bemühungen um einen Standard für das Betriebssystem Unix durch die Industrievereinigung 

X/Open wurden dafür auch Spezifikationen für COBOL vereinbart, deren jüngste von 1991 aus den höchsten Stufen 

der vorgeschriebenen Module von COBOL-85 besteht, mit der Erweiterung von 1989 durch die „Intrinsic 

Functions“, aber ohne Report-Writer, Segmentierung und Debugging, dafür aber mit eigenen Erweiterungen für 

Interaktion mit Bildschirmformularen (SCREEN SECTION und ACCEPT/DISPLAY), gemeinsamen Zugriff auf 

Dateien mit Sperren auf Dateien und Sätze, sowie Internationalisierung mit z. B. Doppelbyte-Zeichensätzen. 

Standardisierung durch ANSI 

Im Jahr 1960 wurde, angeregt durch den Industrieverband „Computer and Business Equipment Manufacturers 

Association“, im Rahmen der US-amerikanischen Standardisierungsorganisation (ASA) ein „Committee on 

Computers and Information Processing“ mit der Nummer X3, geschaffen, welches dann einen Unterausschuss X3.4 

für Programmiersprachen einrichtete, der wiederum einen Unterausschuss X3.4.4 für COBOL einrichtete. Im 

Dezember 1962 wurden Hersteller und andere Interessierte zur Mitarbeit an der Standardisierung eingeladen, wobei 

dann festgelegt wurde, dass die Standardisierung auf den Publikationen des CODASYL fußen sollten. 

Der erste Standard wurde am 23. August 1968 als USA Standard COBOL 1968 verabschiedet und als Dokument 

X3.23-1968 veröffentlicht. 

Der Ausschuss X3.4.4 wurde dann zum Technischen Komitee X3J4, wie er auch heute noch heißt, und machte sich 

an die Arbeit, den nächsten Standard zu entwickeln, der dann am 10. Mai 1974 als American National Standard 

COBOL 1974 verabschiedet und dann im Dokument ANS X3.23-1974 veröffentlicht wurde. 

Der nächste Standard wurde im April 1985 von X3J4 verabschiedet und im September vom zuständigen 

Entscheidungsgremium der inzwischen ANSI heißenden Organisation angenommen und dann als ANS X3.23-1985 

veröffentlicht. COBOL-85 führte mit Begrenzern wie END-IF und END-PERFORM erstmals die Möglichkeit ein, in 

COBOL beliebig geschachtelte Entscheidungs- (IF, EVALUATE) und Wiederholungsanweisungen (PERFORM) zu 

schreiben und damit die sogenannte „Strukturierte Programmierung“ in COBOL zu praktizieren. Zu COBOL-85 

wurde später ein Zusatz mit eingebauten (intrisic) Funktionen und ein weiterer mit Korrekturen zum Standard 

veröffentlicht. 

Der aktuelle Standard wurde 2002 verabschiedet. Wesentliche Änderungen darin sind die Übernahme der 

Erweiterungen durch X/Open, die explizite Unterstützung von internationalen Zeichensätzen einschließlich Unicode, 

die Objektorientierte Programmierung sowie bedingte Compilierung, neben zahlreichen anderen Erweiterungen und 

Präzisierungen. 

Nach dem Ende von CODASYL hat das Komitee J4 auch die Verantwortung nicht nur für die Standardisierung, 

sondern auch für die Entwicklung übernommen. 

Der nächste Standard wird für das Jahr 2008 vorbereitet.

COBOL 43 

Internationale Standardisierung bei ISO 

Das Komitee X3J4 (früher X3.4.4) hat von Anfang an eng mit verschiedenen internationalen Gremien 

zusammengearbeitet. Dementsprechend stimmte ANS COBOL X3.23-1968 mit der ISO-Empfehlung für COBOL 

überein. 

In der ISO ist das Technical Committee ISO/TC 97, Computers and Information Processing zuständig, dessen 

Sekretariat vom ANSI gestellt wird. 

ISO hat zu COBOL eine Empfehlung (Recommendation) R-1989:1972 sowie Standards ISO 1989:1978 und ISO 

1989:1985 verabschiedet und dabei die Vorgabe des US-Standardisierungsgremiums übernommen. 

Der aktuelle Standard 2002 ist umgekehrt zuerst als ISO/IEC 1989:2002 veröffentlicht und dann von den nationalen 

Standardorganisationen übernommen worden. 

Module und standardkonforme Implementierungen 

COBOL-68, COBOL-74 und COBOL-85 ordneten die verschiedenen Features der Sprache einem Modul mit jeweils 

einem bis drei „Levels“ zu, woraus dann minimale und volle Implementierungen des Standards als Kombination von 

bestimmten Levels der jeweiligen Module definiert wurden. Eine mit COBOL-2002 konforme Implementierung 

muss den gesamten Sprachumfang implementieren. 

COBOL-Compiler 

Für Computer der Klassen „Großrechner“ und „Mittlere Datentechnik“ boten und bieten deren jeweilige Hersteller – 

IBM, Unisys, Siemens, Fujitsu-Siemens, HP, Bull u. a. – auf ihre proprietären Betriebssysteme zugeschnittene 

COBOL-Compiler an, z. T. verschiedene Compiler, die beispielsweise verschiedenen Standards entsprechen. 

Für Betriebssysteme, die aus der UNIX- bzw. MS-DOS-Tradition entstanden sind, gibt es COBOL-Compiler von 

verschiedenen Software-Herstellern. Näheres siehe in der unten verlinkten COBOL-FAQ von William M. Klein. 

Siehe auch 

• ACUCOBOL 

Weblinks 

• Website des COBOL-Standards [2] 

• COBOL User Groups (COBUG) [3] 

• X/Open-COBOL-Spezifikationen [4] 

• COBOL-FAQ von William M. Klein [5] 

• Ein übersichtliches und gut dokumentiertes COBOL-Programm mit Quellcode und ausführbarer EXE für 

Windows [6] 

• Handbücher zu ILE Cobol [7]

COBOL 44 

Referenzen 

[1] http:/ / www. opencobol. org/ 

[2] http:/ / www. cobolstandards. com/ 

[3] http:/ / www. cobug. com/ 

[4] http:/ / www. opengroup. org/ bookstore/ catalog/ c192. htm 

[5] http:/ / home. comcast. net/ ~wmklein/ FAQ/ COBOLFAQ. htm 

[6] http:/ / www. vaeter-aktuell. de/ x/ Ziegenproblem 

[7] http:/ / publib. boulder. ibm. com/ html/ as400/ v5r1/ ic2929/ info/ rzahgcobol. htm 

D (Programmiersprache) 

Paradigmen: imperativ, objektorientiert, generisch, modular 


Entwickler: Walter Bright 

Aktuelle Version: 

Typisierung: Stark, statisch 

wichtige Implementierungen: DMD [3] , GDC [4] , LDC 

Einflüsse: C, C++, Java, C# 

D 

[1] [2] 

1.045 (stable), 2.030 (alpha) (11. Mai 2009 

) 

D ist eine Programmiersprache, die sich äußerlich stark an C++ anlehnt. Ebenso wie C++ ist D für die 

Systemprogrammierung geeignet. D wird seit 1999 von Walter Bright entwickelt und wurde am 3. Januar 2007 in 

der stabilen Version 1.0 veröffentlicht. [5] 

Seit dem 17. Juni 2007 gibt es einen experimentellen 2.0-er-Version-Zweig, in dem die Sprache weiter entwickelt 

wird. 

Sprachmittel 

Die Sprache D übernimmt die meisten Sprachmittel der Sprache C. Auch die C-Standardbibliothek ist Bestandteil 

von D. Dadurch besteht Kompatibilität zu in C geschriebenen Programmen. Kompatibilität mit C++ gibt es hingegen 

nicht. 

D ist eine objektorientierte, imperative Programmiersprache und verfügt über Templates und überladbare 

Operatoren. Gegenüber C++ bietet es außerdem Design by contract, Module und eine integrierte automatische 

Speicherbereinigung. Letztere kann sowohl global als auch für einzelne Objekte deaktiviert und durch eine eigene 

Speicherverwaltung ersetzt werden.


Compiler 

Es gibt mehrere Compiler für die Sprache D, den DMD (Digital Mars D) [3] vom Erfinder Walter Bright für Windows 

und Linux, sowie GDC [4] , eine Implementierung für GCC für verschiedene Plattformen. 

Des Weiteren gibt es inzwischen drei Compiler für D, die selbst in D programmiert wurden. Dies sind der 

DIL-Compiler [6] , Dang [7] und der LDC [8] , welche allesamt kompatibel zu LLVM sind. 

Entwicklungsumgebungen 

D wird zunehmend von verschiedenen IDEs unterstützt. Zum Einsatz kommen unter anderen die Editoren Entice 

Designer, Emacs, Vim, Scite, Scite4D, Smultron, TextMate, Zeus und Geany. Vim und Scite4D unterstützen 

Syntaxhervorhebung und Autovervollständigung. Für TextMate existiert eine Erweiterung und Code::Blocks 

unterstützt D teilweise. Allerdings werden Autovervollständigung und Refactoring momentan von keiner IDE für D 

komplett bereitgestellt. Darüber hinaus gibt es noch für Eclipse mit dem Plugin Descent [9] Unterstützung für D. 

Zudem gibt es in D geschriebene IDEs, wie z. B. Poseidon. Letztere unterstützt Autovervollständigung, Refactoring 

und hat einen integrierten Debugger. 

D Anwendungen können mit jedem beliebigen C/C++ Debugger debuggt werden, wie z.B. GDB oder WinDbg, 

wobei die Unterstützung für bestimmte grundlegende Sprachfeatures stark eingeschränkt ist. Ein Debugger speziell 

für D ist Ddbg für Windows. Der kommerzielle ZeroBUGS Debugger für Linux unterstützt D experimentell. Ddbg 

kann mit den verschiedensten IDEs oder von der Kommandozeile aus benutzt werden, während ZeroBUGS eine 

eigene GUI mitbringt. 

Programmbeispiel 

// Programm, geschrieben in D, das seine Parameter ausgibt 

import std.stdio; // importiert die Funktion writefln() 

void main(string[] args) 

{ 

foreach(int i, string a; args) { 

writefln("Parameter %d = '%s'", i, a); // Jeder Eintrag im Feld 

args wird ausgegeben. 

} 

} 

Erläuterung 

Der main-Funktion werden die Parameter als ein Feld von Zeichenketten (Strings) übergeben. Ruft man dieses 

Programm unter Windows mit beispiel.exe -win -s auf, dann gibt es diesen Text in einem 

Konsolen-Fenster aus: 

Parameter 0 = 'beispiel.exe' 

Parameter 1 = '-win' 

Parameter 2 = '-s' 

Siehe auch: Hallo Welt in D


Weblinks 

• Die Programmiersprache D [10] bei Digital Mars (Downloads, englisch) 

• dsource.org [11] D-Projektseite (englisch) 

• Manfred Hansen: Programmiersprache D. [12] 2010, 167 S. (PDF-Datei, 1,9 MB) 

Literatur 

• Tobias Wassermann, Christian Speer: Programmieren in D, 1. Auflage (November 2007), 165 Seiten, 

entwickler.press, ISBN 978-3939084693. 

Referenzen 

[1] D 1.0 Change Log, http:/ / www. digitalmars. com/ d/ 1. 0/ changelog. html 

[2] D 2.0 Change Log, http:/ / www. digitalmars. com/ d/ 2. 0/ changelog. html 

[3] DMD (Digital Mars D): DMD (http:/ / www. digitalmars. com/ d/ dcompiler. html) 

[4] GDC (GNU D Compiler): GDC (http:/ / dgcc. sourceforge. net/ ) 

[5] Heise Online: Eleganter programmieren: D ist da (http:/ / www. heise. de/ newsticker/ meldung/ 83145), 3. Januar 2007 – 14:52 

[6] DIL-Projektseite (http:/ / code. google. com/ p/ dil/ ) 

[7] Dang-Projektseite (http:/ / www. dsource. org/ projects/ dang) 

[8] LDC-Projektseite (http:/ / dsource. org/ projects/ ldc) 

[9] Descent-Projektseite (http:/ / www. dsource. org/ projects/ descent) 

[10] http:/ / www. digitalmars. com/ d/ 

[11] http:/ / www. dsource. org/ 

[12] http:/ / www. steinmole. de/ d/ d_buch. pdf 

DarkBASIC 

DarkBASIC 

Entwickler: The Game Creators Limited 

Aktuelle Version: Classic: 1.21 (14.08.2008), 

Professional: 1.074 (23.07.2009) 

Betriebssystem: Windows 

Kategorie: Compiler 

Lizenz: proprietär 

Deutschsprachig: IDE/Hilfe 

darkbasic.thegamecreators.com [1] 

DarkBASIC ist der Name einer integrierten Entwicklungsumgebung (IDE) und einer Programmiersprache, welche 

beide von der britischen Firma „The Game Creators“ entwickelt wurden. Die Sprache ist ein BASIC-Dialekt und 

greift auf die DirectX-Bibliotheken von Microsoft zurück. Ein besonderes Merkmal ist, dass Befehle auch 

Leerzeichen enthalten können. 

DarkBASIC ermöglicht einen einfachen Umgang mit 3D-Objekten, Grafiken, Sounds sowie anderen Medien.

DarkBASIC 47 

DarkBASIC 

Die erste Version von DarkBASIC, auch DarkBASIC Classic genannt(kurz: DB oder DBC), erschien 1999. In dieser 

Variante werden die erstellten Programme BASIC-typisch interpretiert. DarkBASIC benutzt die Funktionen der 

DirectX-Versionen 6 bis 8.1. 

Durch einen Patch, der im Jahr 2000 erschien, wurden Netzwerk-Funktionen hinzugefügt. Diese Version wird 

inzwischen nicht mehr weiter entwickelt. 

Der Hersteller betreibt ein Programm, welches diese Software für Schulen kostenlos anbietet. 

DarkBASIC Professional 

Die Professional-Version von DarkBASIC (kurz: DBP), welche in Deutschland unter dem Namen „3D Games 

Creator“ vertrieben wird, erschien im Jahr 2002. 

Sie beinhaltet eine komplett neue, benutzerfreundlichere IDE und zahlreiche Verbesserungen, welche die Sprache 

und die Technik der mitgelieferten Befehle betrifft. Beispielsweise unterstützt DarkBASIC Professional viele neue 

Formate, die es in der Classic-Version nicht gab. Unter anderem gehören dazu Half-Life- oder Quake III 

Arena-Karten, außerdem werden die Programme in echten Maschinencode übersetzt. 

Diese Variante von DarkBASIC nutzt außerdem die DirectX-Versionen 8 und 9 (aktuell 10.0 Februar 2008). 

Für diese Version existieren zahlreiche Erweiterungen des Herstellers selbst, sowie von der Community 

bereitgestellte. 

Sprachumfang 

Kategorie Beispiele neu in DBP 

Core If [2] 

System Call Dll [5] 

Mathematik Sin [8] 

Input/Output Print [11] 

Netzwerk Ftp Connect [14] 

Audio Play Sound [17] 

2Dimensional Circle [20] 

Dim [3] 

Fog Available [6] 

Inc [9] 

Mouseclick [12] 

Create Net Game 

[15] 

Load 3DSound [18] 

Blur Bitmap [21] 

3Dimensional Make Object Sphere [23] Point Light [24] 

And [4] 

Make Memory [7] 

Make Vector3 [10] 

Make Memblock From File [13] 

Http Connect [16] 

Set Music Volume [19] 

Load DVD Animation [22] 

Load BSP [25] 

Kategorie Beispiele neu in DBP

DarkBASIC 48 

Quelltextbeispiele 

Hello World 

PRINT "Hello World" 

WAIT KEY `der Befehl ist nötig damit das Programm nicht sofort 

beendet wird 

3D-Beispiel 

Bewege einen Würfel über den Bildschirm mit den Pfeiltasten 

sync on ` aktiviere die manuelle Bildschirmsyncronisation 

sync rate 60 ` setze die Bildschirmwiederholungsrate auf 60Hz 

rem deaktiviere die automatische Programmbeendung durch die 

[Esc]-Taste 

neu 

disable escapekey 

make object cube 1, 100 ` erstelle einen Würfel mit der größe 100 

posz = 10 

posx = 10 

posy = 10 

repeat ` start Hauptschleife 

` Steuere die Position des Würfels 

if upkey() = 1 then inc posy 

if downkey() = 1 then dec posy 

if leftkey() = 1 then dec posx 

if rightkey() = 1 then inc posx 

position object 1, posx, posy, posz ` positioniere das Objekt 

sync ` aktualisiere das Bild 

until escapekey() = 1 ` beende die Hauptschleife, wenn [Esc]-Taste 

gedrückt 

delete object 1 ` lösche das am Anfang erstelle Objekt 

end ` beende das Programm 

Sync On 

Die Sync On ist ein seit 2002 jährliches stattfindendes Treffen der deutschen DarkBASIC Community, hier werden 

Vorträge zur Spieleentwicklung gehalten, Spiele sowie Programme vorgestellt. Bei diesen Treffen war auch bereits 

der Hauptentwickler Lee Bamber aus dem Vereinigten Königreich zu Gast. Folgende Veranstaltungsorte sowie 

Gastgeber traten in der Vergangenheit auf. 

• 2002 in Bamberg von Thomas Görtler und Michael Karg 

• 2003 in Bamberg von Thomas Görtler und Michael Karg 

• 2004 in Bamberg von Thomas Görtler 

• 2005 in Berlin von D-Man 

• 2006 in Altenstadt von Stephan Geist

DarkBASIC 49 

mit DarkBASIC erstellte Programme 

• FPS Creator – Ein Programm, welches ein einfaches Zusammenstellen eines Ego-Shooters ermöglicht. 

• Tom Yum Goong – Spielumsetzung des gleichnamigen Films, mehr als 30.000 Einheiten wurden verkauft. 

Literatur 

• Jonathan S. Harbour: DarkBASIC Pro Game Programming, Second Edition, Course Technology, ISBN 

1598632876 (englisch) 

• Alistair Stewart: Hands On DarkBASIC Pro - Volume 1, Digital Skills, ISBN 1-874107-08-4 (englisch) 

Weblinks 

• Homepage des Herstellers [26] (englisch) 

• Offizielle Homepage [27] (deutsch) 

• de.dbLounge.org [28] – Wiki für Befehle, Anleitungen, Codes und Begriffe (deutsch) 

Referenzen 

[1] http:/ / darkbasic. thegamecreators. com/ 

[2] http:/ / dblounge. org/ command. php?name=IF 

[3] http:/ / dblounge. org/ command. php?name=DIM 

[4] http:/ / dblounge. org/ command. php?name=AND 

[5] http:/ / dblounge. org/ command. php?name=CALL%20DLL 

[6] http:/ / dblounge. org/ command. php?name=FOG%20AVAILABLE 

[7] http:/ / dblounge. org/ command. php?name=MAKE%20MEMORY 

[8] http:/ / dblounge. org/ command. php?name=SIN 

[9] http:/ / dblounge. org/ command. php?name=INC 

[10] http:/ / dblounge. org/ command. php?name=MAKE%20VECTOR3 

[11] http:/ / dblounge. org/ command. php?name=PRINT 

[12] http:/ / dblounge. org/ command. php?name=MOUSECLICK 

[13] http:/ / dblounge. org/ command. php?name=MAKE%20MEMBLOCK%20FROM%20FILE 

[14] http:/ / dblounge. org/ command. php?name=FTP%20CONNECT 

[15] http:/ / dblounge. org/ command. php?name=CREATE%20NET%20GAME 

[16] http:/ / dblounge. org/ command. php?name=HTTP%20CONNECT 

[17] http:/ / dblounge. org/ command. php?name=PLAY%20SOUND 

[18] http:/ / dblounge. org/ command. php?name=LOAD%203DSOUND 

[19] http:/ / dblounge. org/ command. php?name=SET%20MUSIC%20VOLUME 

[20] http:/ / dblounge. org/ command. php?name=CIRCLE 

[21] http:/ / dblounge. org/ command. php?name=BLUR%20BITMAP 

[22] http:/ / dblounge. org/ command. php?name=LOAD%20DVD%20ANIMATION 

[23] http:/ / dblounge. org/ command. php?name=MAKE%20OBJECT%20SPHERE 

[24] http:/ / dblounge. org/ command. php?name=POINT%20LIGHT 

[25] http:/ / dblounge. org/ command. php?name=LOAD%20BSP 

[26] http:/ / www. thegamecreators. com/ 

[27] http:/ / www. darkbasic. de/ 

[28] http:/ / de. dblounge. org/

FORTRAN 50 

FORTRAN 

Fortran 

Paradigmen: prozedural, imperativ, strukturiert, objektorientiert 


Entwickler: John W. Backus, IBM 

Typisierung: statisch, stark 

wichtige Implementierungen: gfortran, g95, Open Watcom, XL Fortran, Intel und andere 

Beeinflusste: Algol 58, PL/I, BASIC 

Fortran ist eine prozedurale und in ihrer neuesten Version zusätzlich eine objektorientierte Programmiersprache, die 

insbesondere für numerische Berechnungen eingesetzt wird. Der Name entstand aus FORmula TRANslation und 

wurde bis zur Version FORTRAN 77 mit Großbuchstaben geschrieben. 

Geschichte 

Fortran gilt als die erste jemals tatsächlich realisierte höhere Programmiersprache. Sie geht zurück auf einen 

Vorschlag, den John W. Backus, Programmierer bei IBM, 1953 seinen Vorgesetzten unterbreitete. 

Dem Entwurf der Sprache folgte die Entwicklung eines Compilers durch ein IBM-Team unter Leitung von John W. 

Backus. Das Projekt begann 1954 und war ursprünglich auf sechs Monate ausgelegt. Tatsächlich konnte Harlan 

Herrick, der Erfinder der später heftig kritisierten Goto-Anweisung, am 20. September 1954 das erste 

Fortran-Programm ausführen. Doch erst 1957 wurde der Compiler für marktreif befunden und mit jedem 

IBM-704-System ausgeliefert. Backus hatte darauf bestanden, den Compiler von Anfang an mit der Fähigkeit zu 

Optimierungen auszustatten: Er sah voraus, dass sich Fortran nur dann durchsetzen würde, wenn ähnliche 

Ausführungsgeschwindigkeiten wie mit bisherigen Assembler-Programmen erzielt würden. 

Versionen 

Fortran wurde mehrmals erweitert. Viele neue Sprachelemente wurden zunächst von einem einzelnen Hersteller 

eingeführt und später in den internationalen Standard übernommen. Als Versionen folgten aufeinander FORTRAN I, 

FORTRAN II, FORTRAN IV, FORTRAN-66, FORTRAN-77, Fortran 90, Fortran 95, Fortran 2000, Fortran 2003 

und zuletzt Fortran 2008. Ab FORTRAN-66 ist Fortran von einer internationalen Organisation standardisiert. Die 

Fortschreibung der Standards ist ein komplizierter Prozess, der oft wesentlich länger dauert als zunächst angestrebt: 

Der Nachfolger des 1978 erschienenen Standards FORTRAN-77, der als Fortran 8x bezeichnet wurde, war 

ursprünglich für das Jahr 1982 geplant, später dann für das Jahr 1985, und wurde schließlich unter der Bezeichnung 

Fortran90 erst am 11. April 1991 als neuer Standard und Nachfolger von FORTRAN-77 angenommen. [1] 

Im Laufe dieser Erweiterungen wurden zahlreiche Sprachelemente aus später entstandenen Programmiersprachen 

übernommen. Beruhte früher Fortran-Stil noch ganz auf Goto-Anweisungen, kann man seit FORTRAN 77 

uneingeschränkt strukturiert programmieren. Mit Fortran 90 wurde neben dem aus der Lochkartenzeit stammenden 

festen Zeilenformat ein von späteren Programmiersprachen verwendetes freieres Format erlaubt. Ab Fortran 90 

werden interessante Elemente eingeführt, die auch z. B. in Ada vorhanden sind, beispielsweise optionale Parameter 

und die Möglichkeit, Prozedurparameter nicht nur über die Position in der Parameterliste zu identifizieren, sondern 

auch über ihren Namen. 

Beispiel:

FORTRAN 51 

SUBROUTINE test( Argument1, Argument2, Argument3 ) 

REAL, INTENT(IN) :: Argument1 

CHARACTER(LEN= *), INTENT(IN) :: Argument2 

INTEGER, INTENT(IN), OPTIONAL :: Argument3 

! Hier was sinnvolles. 

END SUBROUTINE 

Mögliche Aufrufe sind dann z. B.: 

CALL test( 1.0, 'Tach' ) 

CALL test( Argument1= 1.0, Argument2= 'Tach auch' ) 

CALL test( Argument2= 'Tach Auch', Argument1= 1.0 ) 

CALL test( Argument3= 3, Argument1= 1.0, Argument2= 'Tach auch' ) 

Während beim ersten Aufruf die Parameterassoziation über die Reihenfolge der Parameter erfolgt, so werden bei den 

anderen Beispielen die Parameter mittels der Namen identifiziert. Bei letzteren spielt die Reihenfolge dann keine 

Rolle mehr. 

Varianten 

Einige von Fortran abgeleitete Programmiersprachen sind Ratfor, F und HPF (High Performance Fortran). 

Eigenschaften 

Fortran war und ist für numerische Berechnungen vorgesehen und optimiert. Von Anfang an hatte Fortran den 

Potenz-Operator ** – der in vielen anderen Hochsprachen nicht vorhanden ist – und einen Datentyp für komplexe 

Zahlen. Mit Fortran90 wurden Vektor- und Matrix-Operationen standardisiert. 

Ein Fortran-Programm kann leichter optimiert werden als z. B. ein C-Programm, da Fortran restriktiver ist. 

Beispielsweise ist es nicht erlaubt, innerhalb einer Iterationsschleife die Iterationsvariable zu verändern. Unter 

anderem ist deshalb beim Eintritt in die Schleife die Maximalzahl der Durchläufe bekannt. 

! iFunc() sei eine Funktion, die einen INTEGER-Wert berechnet. 

! Der Compiler muss nur einen Aufruf von iFunc erzeugen. 

DO i = 1, iFunc(4711) 

ENDDO 

!.. sinnvolles hier. 

! Innerhalb dieser Schleife darf i nicht verändert werden. 

In C sieht eine solche Iteration so aus: 

for (i = 1; i

FORTRAN 52 

C++ portiert wurde. 

Implizite Variablendeklaration 

In Anlehnung an mathematischen Notationsgebrauch sind Variablen in Fortran standardmäßig über ihren 

Anfangsbuchstaben deklariert: Bezeichner, die mit einem der Buchstaben i, j, k, l, m, n beginnen, stehen für eine 

INTEGER-Variable oder einen INTEGER-Funktionswert, alle übrigen Bezeichner stehen für REAL-Werte. Diese 

impliziten Typenvereinbarung von Variablen kann durch die Deklaration einzelner Variablen überschrieben werden, 

sie kann durch eine Zeile wie 

! Alle nichtdeklarierten Bezeichner, deren erster Buchstabe c oder z 

ist, bezeichnen komplexe Zahlen. 

IMPLICIT COMPLEX (c, z) 

verändert werden, und die implizite Vereinbarung kann durch den Befehl 

IMPLICIT NONE 

ganz aufgehoben werden. In diesem Fall löst die Verwendung eines nichtdeklarierten Bezeichners einen Fehler 

während der Übersetzung aus. Dadurch vereinfacht sich die Fehlersuche erheblich. 

Übergabe von Parametern 

In alten Versionen von Fortran (FORTRAN 77 und früher) brauchten Unterprogramme vor ihrer Verwendung nicht 

deklariert zu werden. Es konnte durch eine Deklaration allenfalls der Typ des Rückgabewerts festgelegt werden. Der 

Compiler überprüfte normalerweise nicht, ob ein Unterprogrammaufruf mit typrichtigen Parametern erfolgt. Die 

Übergabe von Parametern an Unterprogramme (SUBROUTINE oder FUNCTION) erfolgt üblicherweise per 

Adresse. Vor Fortran-90 konnten grundsätzlich alle Aktualparameter von einer SUBROUTINE oder FUNCTION 

verändert werden. Deshalb müssen alle Parameter z. B. durch Adressübergabe übergeben werden. Eine automatische 

Typumwandlung kann deshalb auch nicht stattfinden. 

Die meisten Fortran-Systeme führen auch keine Typüberprüfung zur Laufzeit durch. 

Das ist eine häufige Fehlerquelle. Programmbeispiel 1: 

... 

CALL DruckeZahl(3.14) 

... 

SUBROUTINE DruckeZahl(meineZahl) 

... 

Im Unterprogramm DruckeZahl ist meineZahl, weil mit m beginnend, implizit als INTEGER deklariert. Zur Laufzeit 

erfolgt ein Aufruf mit dem REAL Argument 3.14. Dann wird die INTEGER-Variable meineZahl mit den Bits der 

Gleitkommadarstellung von 3.14 aufgefüllt – was auf beliebig abwegige numerische Ergebnisse führt. 

Viele Fortran-Compiler arbeiten mit Zeigern zur Übergabe von Parametern. Das führt zu teilweise amüsanten 

Ergebnissen, z. B. folgendes Programmbeispiel 2: 

call bar(3) 

print *,3 

end 

subroutine bar(i) 

i = 42 

end

FORTRAN 53 

Dieses würde bei manchen Compilern die Zahl 42 ausgeben. Das Programm ist allerdings so nicht korrekt. 

Programmierwerkzeuge wie ftnchek [2] ermöglichen allerdings eine separate Prüfung der Übereinstimmung von 

Argumentlisten und würden in diesen Fällen warnen. 

In Fortran 90 und nachfolgenden Versionen besteht die Möglichkeit, die Parametertypen der Unterprogramme 

anhand von Schnittstellen (INTERFACE) und Modulen (MODULE) zu definieren. Der Compiler kann somit 

überprüfen, ob der übergebene Parametertyp und der erwartete Typ übereinstimmen. Diese Bekanntgabe ist 

allerdings nicht zwingend, so wie es in anderen Programmiersprachen, beispielsweise Ada der Fall ist. Die von 

Fortran-95 abgeleitete Programmiersprache F erzwingt dieses, in F sind nur Aufrufe von Unterprogrammen erlaubt, 

deren Parameterliste z. B. durch USE-Anweisungen bekannt gemacht sind. In einem Unterprogramm kann auch 

festgelegt werden, ob ein Parameter Eingabeparameter (INTENT(IN)), Ausgabeparameter (INTENT(OUT)) oder 

beides (INTENT(INOUT)) ist. In Fortran 90 deklariert man das Unterprogramm bar folgendermaßen: 

subroutine bar(i) 

integer, intent(in):: i 

[...] 

end subroutine 

Falls das Unterprogramm versuchen sollte, den Wert des Aktualparameter i zu verändern, würde der Compiler einen 

Fehler anzeigen. 

Dynamische Speicherallokation 

Unter dynamischer Speicherallokation versteht man die Möglichkeit, Speicher (insbesondere für Felder wie z. B. für 

Matrizen) erst zur Laufzeit des Programms anzufordern, das heißt, dass die Größe von Arrays nicht bereits zum 

Zeitpunkt des Übersetzen des Programms festgelegt zu sein braucht. Bis Fortran 77 ist eine dynamische 

Speicherallokation nicht oder nur über nicht standardisierte Erweiterungen der Compilerhersteller möglich. Ab 

Fortran 90 ist die dynamische Speicherverwaltung im Sprachstandard enthalten. 

Ein Beispiel für dynamische Speicherreservierung: Anlegen und Bearbeiten einer verketteten Liste: 

TYPE tElement 

TYPE (tElement), POINTER :: Naechstes 

REAL :: Datum 

END TYPE tElement 

TYPE (tElement), POINTER, SAVE :: Liste=> NULL() ! -- NULL(): 

Fortran-95 

TYPE (tElement), POINTER :: Element 

! Anlegen eines Elements und Eintragen am Anfang der Liste 

ALLOCATE( Element ) 

Element% Datum = 4711.0 

Element% Naechstes=> Liste 

Liste=> Element 

! Durchlaufen der Liste: 

Element=> Liste 

DO WHILE (ASSOCIATED(Element)) 

CALL Bearbeiten( Element% Datum )

FORTRAN 54 

ENDDO 

Element=> Element% Naechstes 

Compiler 

Bisher (Januar 2007) gibt es keinen Compiler, der den aktuellen Fortran-Standard von 2003 voll unterstützt. Die 

meisten Compiler unterstützen jedoch Teile des Standards Fortran 2003 [3] . 

Proprietäre Software 

F95-Compiler gibt es für praktisch alle Computer, von Arbeitsplatzrechnern bis zu Supercomputern. Hersteller 

hierfür sind entweder die Computerhersteller wie z. B. IBM, SUN, HP, Intel oder aber spezialisierte 

Softwarehersteller wie z. B. Absoft, PGI, NAG, Lahey, Salford. Reine F77-Compiler werden heute zumeist nicht 

mehr hergestellt, da Fortran77 fast vollständig im Sprachstandard Fortran95 enthalten ist (nur DO-Schleifen mit 

REAL-Iterationsvariablen und Hollerith-Edit-Deskriptoren sind in Fortran95 und später verschwunden). 

Einige der oben genannten Compiler sind für Privatanwender bzw. nichtkommerzielle Nutzung unentgeltlich, zum 

Beispiel die Linux-Variante des Intel-Fortran-Compilers (aktuelle Version 11), Sun Studio Express [4] (mit Fortran, 

C und C++ Compilern für Linux und Solaris), für Microsoft Windows der Compiler von Salford oder DEC Fortran 

für OpenVMS. 

Freie Software 

Seit Version 4.0 enthält die praktisch für alle Plattformen verfügbare GNU Compiler Collection (gcc) einen 

Compiler für Fortran 95 (GNU Fortran). Ältere Versionen von GCC enthalten noch den FORTRAN-77-Compiler 

g77. Außerdem existiert mit G95 [5] ein weiterer freier Compiler für Fortran 95. Aus diesem ging 2003 gfortran 

hervor. 

Auch die OpenWatcom [6] -Entwicklersuite verfügt über einen FORTRAN-77-Compiler. 

Transcompiler 

Es gibt Transcompiler, wie z. B. f2c [7] , zur automatischen Übersetzung von Fortran-77 in (allerdings kaum lesbares) 

C. Auch der NAG-Compiler verwendet als Zwischensprache C; allerdings ist die nötige Laufzeitbibliothek nicht im 

Quelltext zu bekommen. 

Literatur zur Geschichte von Fortran 

• Annals of History of Computing, 6, 1, Jan. 1984. 

• S. Rosen (Hrsg.): Programming Systems and Languages, McGraw Hill, 1967. 

• R. L. Wexelblat (Hrsg.): History of Programmining Languages., Academic Press, 1981, S. 25–74. 

Literatur zu Fortran 

• Michael Metcalf, John Reid, Malcolm Cohen: Fortran 95/2003 Explained, Oxford University Press, 2004, ISBN 

0-19-852693-8 

• Stephen J. Chapman: Fortran 90/95 for Scientists and Engineers - 2nd edition, McGraw Hill, 2004, ISBN 

0-07-123233-8 (International Edition) 

• Thomas Kühme, Peter Witschital: Die FORTRAN-Fibel: Strukturierte Programmierung mit FORTRAN 77, Lehr- 

und Arbeitsbuch für Anfänger, Oldenbourg, 1991, ISBN 978-3-486-22016-2 

• Günter Schmitt: Fortran-90-Kurs - technisch orientiert: Einführung in die Programmierung mit Fortran 90, 

Oldenbourg Verlag, 1996, ISBN 978-3-486-23896-9

FORTRAN 55 

• William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery: Numerical Recipes in FORTRAN 

77: The Art of Scientific Computing - Volume 1 of Fortran Numerical Recipes - 2nd Edition, Cambridge 

University Press, 1992 (zweite Edition), 2003 (Reprint mit Korrekturen), ISBN 0-521-43064-X 

• William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery: Numerical Recipes in Fortran 90: 

The Art of Parallel Scientific Computing - Volume 2 of Fortran Numerical Recipes - 2nd Edition, Cambridge 

University Press, 1996 (erste Auflage), 1999 (Reprint mit Korrekturen), ISBN 0-521-57439-0 

Weblinks 

• Fortran.de [8] Links und Informationen 

• Fortran Store [9] Umfangreiche Informationen inkl. Historischem und Standards (engl.) 

• Einführung in Fortran90/95 [10] 

• Einführung in Fortran90/95 [11] 

Referenzen 

[1] Vorwort von Michael Metcalf in: W. H. Press, S. A. Teukolsky, W. T. Vetterling, B. P. Flannery: Numerical Recipes in Fortran 90. 

Cambridge University Press, 1999, ISBN 0-521-57439-0. 

[2] http:/ / www. dsm. fordham. edu/ ~ftnchek/ 

[3] Ian D. Chivers, Jane Sleightholme, Compiler support for the Fortran 2003 standard, ACM SIGPLAN Fortran Forum 28, 26 (2009). (http:/ / 

doi. acm. org/ 10. 1145/ 1520752. 1520755) ( PDF (http:/ / www. fortranplus. co. uk/ resources/ fortran_2003_compiler_support. pdf)) 

[4] http:/ / developers. sun. com/ prodtech/ cc/ downloads/ express. jsp 

[5] http:/ / g95. org/ 

[6] http:/ / www. openwatcom. org 

[7] http:/ / www. netlib. org/ f2c/ 

[8] http:/ / www. fortran. de/ 

[9] http:/ / www. fortran. com/ 

[10] http:/ / www. rz. uni-bayreuth. de/ lehre/ fortran90/ vorlesung/ index. html 

[11] http:/ / www. kfa-juelich. de/ zam/ docs/ bhb/ bhb_html/ d0124/ d0124. html

FreeBASIC 56 

FreeBASIC 

FreeBASIC 

Basisdaten 

Entwickler: Quelloffen (Open Source) 

Aktuelle Version: 0.20.0 Beta (10.08.2008) 

Betriebssystem: Windows, Linux, FreeBSD und DOS 

Kategorie: Compiler 

Lizenz: GPL/LGPL 

Deutschsprachig: nur IDE 

www.freebasic.net [1] 

FreeBASIC (kurz FB) ist ein kostenloser Open-Source-Compiler, dessen Syntax auf Microsoft QuickBASIC 

aufbaut. Er ermöglicht das Erzeugen von 32-Bit-Anwendungsprogrammen, Spielen etc. für Microsoft Windows, 

Linux, FreeBSD und DOS, teilweise auch für die Xbox. Versionen für weitere Betriebssysteme sind geplant. 

Zurzeit können Bibliotheken wie GTK+, GSL, SDL, Allegro, Lua oder OpenGL direkt genutzt werden, mit jeder 

neuen Version steigert sich jedoch die Anzahl der unterstützten Bibliotheken. 

Die erste Version wurde im November 2004 veröffentlicht, die neueste Version ist Version 0.20.0 (Beta) vom 10. 

August 2008. 

Merkmale 

• Der FreeBASIC-Compiler ("FBC", unter Windows und DOS fbc.exe, unter Linux heißt die Binary lediglich fbc) 

erzeugt lediglich Assembler-Code, welcher mithilfe der GCC-Suite compiliert und gelinkt wird. Durch dieses 

Verfahren können Importbibliotheken von der GCC-Suite direkt übernommen werden. Durch dieses Backend 

können kleine ausführbare Binarys für Windows, DOS und Linux erzeugt werden. 

• Der Compiler ist in verschiedenen Tests schneller als BlitzBasic, Visual Basic und Co. 

• Er beinhaltet einen Inline-Assembler. 

• Er beherrscht Pointer auf Variablen und Funktionen. 

• Er beherrscht das Überladen von Funktionen und Subroutinen (Funktionen ohne Rückgabe), wie beispielsweise 

auch C++ oder Java, und Funktionen und Subroutinen können mit optionalen Parametern (wie zum Beispiel auch 

in PHP) erstellt werden. 

• Er kann im Gegensatz zum DOS-basierten QuickBasic auf fast alle Funktionen zurückgreifen, die heutige 

Programmierer nutzen, wie zum Beispiel die WinAPI und andere Bibliotheken. 

• Alle Funktionen der FBRTL sind plattformunabhängig, d. h. können auf Windows, Linux und DOS 

gleichermaßen verwendet werden. Das ermöglicht das einfache Schreiben plattformunabhängiger Anwendungen. 

• Der Compiler ermöglicht das Schreiben hardwarebeschleunigter Anwendungen durch Verwendung von openGL. 

• Er beinhaltet einige sehr komfortable Sprachkonstrukte wie etwa Shorthands, Makros u. ä., die dem 

Programmierer einige Tipparbeit abnehmen.

FreeBASIC 57 

• Inzwischen ist es zwar möglich, Objekte zu erstellen, jedoch sind einige Elemente der Objektorientierung (z. B. 

Vererbung) noch nicht implementiert. 

Syntax 

Es existieren derzeit über 400 Schlüsselwörter, die z. T. auf mehrerlei Art und Weise verwendet werden können. 

Generell werden drei Arten von Schlüsselwörtern unterschieden: [2] 

• Anweisungen: Anweisungen erfüllen eine bestimmte Aufgabe, etwa die Ausgabe von Text auf dem Bildschirm. 

• Funktionen: Sie zeichnen sich dadurch aus, dass nach ihrem Aufruf ein Wert zur Verfügung gestellt wird, der das 

Ergebnis des Funktionsaufrufs darstellt. Dabei kann der Wert den einzigen Sinn der Funktion darstellen (etwa bei 

mathematischen Funktionen wie LOG), oder nur über den Status des Funktionsaufrufs informieren (Funktionen 

mit Anweisungscharakter, wie GETMOUSE; diese Funktion fragt den Status der Maus ab, und gibt eine Zahl 

zurück, die bestätigt, dass die Abfrage erfolgreich war, oder ob dabei ein Fehler aufgetreten ist.) 

• Klauseln: Sie beeinflussen das Verhalten von Anweisungen und Funktionen, und können losgelöst von diesen 

nicht verwendet werden. 

Die Groß/Kleinschreibung ist dabei, wie bei BASIC üblich, ohne Bedeutung. „GetMouse“ und „GETMOUSE“ 

werden vom Compiler gleich behandelt. 

Beim Umgang mit Werten (Zahlen, Zeichenketten, oder sonstige Arten von Informationen) werden Variablen und 

Konstanten verwendet, STRING-Variablen (Zeichenketten) werden in doppelte Anführungszeichen «"» gesetzt. 

Wird dem String ein «!» vorangestellt, können auch Escape-Sequenzen benutzt werden (z. B. Print !"Hello\nWorld" 

– erzeugt einen Zeilenumbruch zwischen «Hello» und «World»). Mit diesen Variablen und Konstanten kann über 

verschiedene Operatoren gearbeitet werden. Bei Zahlen-Variablen stehen etwa verschiedene mathematische 

Operatoren zur Verfügung (+, −, *, /, LOG, EXP, SIN, ASIN, …). Bei STRINGs hingegen ist die Auswahl der 

Operatoren logischerweise eingeschränkt, möglich ist nur die Verkettung (+ oder &) sowie die Indizierung (mittels 

eckiger Klammern). 

Ein einfaches Hallo-Welt-Programm in FreeBASIC sieht so aus: 

PRINT "Hallo Welt!" 

SLEEP 

• "Hallo Welt!" ist hierbei ein Parameter; in diesem Fall wird also Hallo Welt! auf dem Bildschirm ausgegeben. 

• PRINT ist hierbei eine Anweisung, die bewirkt, dass ein Text auf dem Bildschirm ausgegeben wird. 

• Der SLEEP-Befehl [3] wird nicht benötigt. Er wird nur benutzt, um zu verhindern, dass sich das Ausgabefenster 

der Anwendung automatisch schließt, wenn diese nicht aus der Konsole gestartet wurde. 

Ebenso ist es möglich, innerhalb eines Programmes eigene Befehle zu erstellen, die aus einer Aneinanderreihung 

bestehender Befehle bestehen. Ein solcher eigener Befehl kann eine SUB (Abkürzung für Subroutine) sein, die sich 

wie eine Anweisung verhält, oder eine FUNCTION, die ebenso wie freeBASICs eigene Funktionen einen Wert 

zurückgeben kann. Beide können mit Parametern arbeiten, die auch optional sein dürfen. 

Im Gegensatz zu vielen anderen Sprachen werden Programmbefehle nicht mit einem Semikolon abgeschlossen, 

sondern mit einem Zeilenumbruch wie auch in QBasic. Möchte man einen Befehl über mehrere Zeilen ausdehnen, 

muss am Ende jeder Zeile, die den Befehl nicht beendet, ein Fußstrich geschrieben werden: 

PRINT "Hallo, dieser String"+_ 

" ist ein einzelner String." 

Mehrere Befehle können ohne Zeilenumbruch durch einen Doppelpunkt aneinander gereiht werden. 

Ein weiterer Unterschied zu anderen Sprachen ist, dass bei Subaufrufen die Klammersetzung optional ist: Man kann 

eine Subroutine sowohl mit ProcName(parameter) oder ProcName (parameter) als auch mit ProcName parameter

FreeBASIC 58 

aufrufen, ebenfalls von QBasic abgeleitet. Jedoch ist das nicht bei Funktionen möglich, dort müssen immer 

Klammern gesetzt werden. 

IDE 

Mit FBIde gibt es eine eigene IDE für FreeBasic. Die aktuelle Version 

ist 0.4.6. 

Mehr Möglichkeiten bietet der FreeBASIC-Editor, kurz FBEdit. Es 

gibt ein eigenes Interface zur Gestaltung von Dialogen. 

Weblinks 

• http:/ / www. FreeBASIC. net – englische Webseite des Compilers 

• http:/ / www. freebasic-portal. de – deutschsprachiges Portal über 

FreeBASIC mit Tutorials und Code-Beispielen (komplett 

aktualisiert). 

• http:/ / referenz. FreeBasic-Portal. de – deutschsprachige FreeBASIC-Befehlsreferenz 

• http:/ / www. qb-wettbewerb. de – Programmierwettbewerb zu FreeBASIC und QBasic 

Referenzen 

[1] http:/ / www. freebasic. net 

[2] Weblinks: Online-Befehlsreferenz 

[3] http:/ / www. freebasic-portal. de/ befehlsreferenz/ sleep-400. html 

Hallo Welt 


int main(void) 

{ 

printf("Hallo Welt!\n"); 

return 0; 

} 

Hallo-Welt in C 

FBIde in der Version 0.4.6

Hallo Welt 59 

Ein Hallo-Welt-Programm ist ein kleines Computerprogramm und soll auf 

möglichst einfache Weise zeigen, welche Anweisungen oder Bestandteile für 

ein vollständiges Programm in einer Programmiersprache benötigt werden 

und somit einen ersten Einblick in die Syntax geben. Aufgabe des 

Programms ist, den Text Hallo Welt! oder auf Englisch Hello, world! 

auszugeben. Ein solches Programm ist auch geeignet, die erfolgreiche 

Installation eines Compilers für die entsprechende Programmiersprache zu 

überprüfen. Aufgrund der einfachen Aufgabenstellung kann ein 

Hallo-Welt-Programm für die ersten Schritte in der Sprache dienen, denn es 

folgt zumeist nur dem Programmierparadigma der imperativen 

Programmierung und demonstriert somit zwar nur einen Bruchteil der 

Möglichkeiten, aber durchaus die grundlegenden Elemente der meisten 

Sprachen. 

Hallo-Welt-Programm in der esoterischen 

Programmiersprache Piet. Die Pixel 

stehen für Befehle. 

Die Verwendung des Textes „Hello, world!“, der auch durch einen beliebigen Text ersetzt werden kann, aber 

dennoch gerne unverändert benutzt wird, ist eine Tradition und geht auf ein internes Programmierhandbuch der Bell 

Laboratories über die Programmiersprache C zurück, das Brian Kernighan 1974 verfasste, nachdem er dort schon ein 

Jahr zuvor die Worte „hello“ und „world“ in einer Einführung in die Programmiersprache B verwendet hatte [1] . 

Bekanntheit erlangte der Text jedoch erst durch die Veröffentlichung in dem Buch The C Programming Language 

(deutsch: Programmieren in C) von Brian Kernighan und Dennis Ritchie, auch wenn in dem dortigen Beispiel die 

Schreibung „hello, world“ verwendet wurde. 

Siehe auch 

• Liste von Hallo-Welt-Programmen 

Referenzen 

[1] A Tutorial Introduction to the Language B (http:/ / cm. bell-labs. com/ cm/ cs/ who/ dmr/ btut. pdf) als PDF


Java (Programmiersprache) 

Java 

Basisdaten 

Paradigmen: Objektorientierte Programmiersprache 

Erscheinungsjahr: 

1995 [1] 

Entwickler: Sun Microsystems 

Aktuelle Version: 6.18 (17. Dezember 2009) 

Aktuelle Vorabversion: 7.0 M5 (12. November 2009) 


Einflüsse: 

C++, Smalltalk, Objective C, C# [2] 

Beeinflusste: Groovy, Clojure, C#, Scala 


Lizenz: GNU General Public License/Java Community Process 

java.sun.com [3] 

Java ist eine objektorientierte Programmiersprache und eingetragenes Warenzeichen der Firma Sun Microsystems. 

Sie ist ein Bestandteil der Java-Technologie. 

Java-Programme werden in Bytecode übersetzt und dann in einer speziellen Umgebung ausgeführt, die als 

Java-Laufzeitumgebung oder Java-Plattform bezeichnet wird. Deren wichtigster Bestandteil ist die Java Virtual 

Machine (Java-VM), die die Programme ausführt, indem sie den Bytecode interpretiert und bei Bedarf kompiliert 

(Hotspot-Optimierung). 

Java-Programme sind plattformunabhängig, das heißt sie laufen in aller Regel ohne weitere Anpassungen auf 

verschiedenen Computern und Betriebssystemen, für die eine Java-VM existiert. Sun selbst bietet Java-VMs für die 

Betriebssysteme Linux, Solaris und Windows an. Andere Hersteller lassen ihre Java-VM für ihre Plattform 

zertifizieren, zum Beispiel die Firma Apple für Mac OS X. 

Von Portierung spricht man bei Java in der Regel, wenn Quelltext oder Bytecode auf den Stand einer anderen 

Java-Version angepasst werden soll. Meistens sind Java-Programme nur für bestimmte Java-Versionen getestet oder 

zertifiziert.


Grundkonzepte der Sprache 

[4] [5] 

Der Entwurf der Programmiersprache Java strebte im Wesentlichen fünf Ziele an: 

• Sie soll eine einfache objektorientierte, verteilte und vertraute Programmiersprache sein. 

• Sie soll robust und sicher sein. 

• Sie soll architekturneutral und portabel sein. 

• Sie soll sehr leistungsfähig sein. 

• Sie soll interpretierbar, parallelisierbar und dynamisch sein. 

Einfachheit 

Java ist im Vergleich zu anderen objektorientierten Programmiersprachen wie C++ oder C# einfach, da es 

einen reduzierten Sprachumfang besitzt und beispielsweise Operator Overloading, Pointer, 

Mehrfachvererbung nicht unterstützt. 

Objektorientierung 

Verteilt 

Vertrautheit 

Robustheit 

Sicherheit 

Java gehört zu den objektorientierten Programmiersprachen. 

Javas Klassenbibliothek bietet eine Reihe einfacher Möglichkeiten für Netzwerkkommunikation, von 

TCP/IP-Protokollen über Remote Method Invocation zu Webservices. 

Wegen der syntaktischen Nähe zu C++, der ursprünglichen Ähnlichkeit der Klassenbibliothek zu 

Smalltalk-Klassenbibliotheken und der Verwendung von Entwurfsmustern in der Klassenbibliothek zeigt Java 

für den erfahrenen Programmierer keine unerwarteten Effekte. 

Viele der Designentscheidungen bei der Definition von Java reduzieren die Wahrscheinlichkeit ungewollter 

Systemfehler: Zu nennen sind die starke Typisierung, Garbage Collection, Referenzen statt Pointer, Exception 

Handling. 

Dafür stehen Konzepte wie der Code-Verifier, der sicherstellt, dass die JVM keinen ungültigen Bytecode 

ausführen kann, der Class-Loader, der die sichere Zuführung von Klasseninformationen zur JVM steuert und 

Security-Manager, die sicherstellen, dass nur Zugriff auf Programmobjekte erlaubt wird, für die entsprechende 

Rechte vorhanden sind. 

Architekturneutralität 

Portabilität 

Java wurde so entwickelt, dass dieselbe Version eines Programms prinzipiell auf jeder beliebigen 

Computerhardware läuft, unabhängig von ihrem Prozessor oder anderen Hardwarebestandteilen. 

Zusätzlich zur Architekturneutralität ist Java auch portabel. Das heißt, dass primitive Datentypen sowohl in 

ihrer Größe und internen Darstellung als auch in ihrem arithmetischen Verhalten standardisiert sind. 

Beispielsweise ist ein float immer ein IEEE 754 Float von 32 Bit. Dasselbe gilt auch für die Klassenbibliothek, 

die beispielsweise unabhängig vom Betriebssystem dasselbe GUI erzeugen kann. 

Leistungsfähigkeit 

Java ist insbesondere auf Grund der dynamischen Optimierungen der Virtual Machine eine der effizientesten 

Programmiersprachen und liefert ähnliche Geschwindigkeiten wie C++ oder C# Programme. 

Interpretierbarkeit 

Java ist eine interpretierbare Sprache. Die Java Virtual Machine interpretiert auch Java-Bytecode, bevor sie ihn 

aus Performancegründen compiliert und optimiert.


Parallelisierbarkeit 

Dynamisch 

Java unterstützt Multithreading, also den parallelen Ablauf von eigenständigen Programmmabschnitten. Dazu 

bietet die Sprache selbst die Keywords synchronized und volatile – Konstrukte, die das „Monitor & Condition 

Variable Paradigma“ von C.A.R. Hoare [6] unterstützen. Die Klassenbibliothek enthält weitere Unterstützungen 

für parallele Programmierung mit Threads. 

Java ist so aufgebaut, dass es sich an dynamisch ändernde Rahmenbedingungen anpassen lässt. Da die Module 

erst zur Laufzeit gelinkt werden, können beispielsweise Teile der Software (etwa Bibliotheken) neu 

ausgeliefert werden, ohne die restlichen Programmteile anpassen zu müssen. Interfaces können als Basis für 

die Kommunikation zwischen zwei Modulen eingesetzt werden, die eigentliche Implementierung kann aber 

dynamisch und beispielsweise auch während der Laufzeit geändert werden. 

Objektorientierung 

Die Grundidee der objektorientierten Programmierung ist die softwaretechnische Abbildung in einer Art und Weise, 

wie wir Menschen auch Dinge der realen Welt erfahren. Die Absicht dahinter ist, große Softwareprojekte einfacher 

zu verwalten und die Qualität der Software zu erhöhen. Ein weiteres Ziel der Objektorientierung ist ein hoher Grad 

der Wiederverwendbarkeit von Softwaremodulen. 

Ein neuer Aspekt von Java gegenüber den objektorientierten Programmiersprachen C++ und Smalltalk ist die 

explizite Unterscheidung zwischen Schnittstellen und Klassen, die durch entsprechende Schlüsselwörter interface 

und class ausgedrückt wird. Java unterstützt kein Erben von mehreren unabhängigen Basisklassen (sogenannte 

„Mehrfachvererbung“ wie in C++ oder Eiffel), wohl aber das Implementieren einer beliebigen Zahl von 

Schnittstellen, womit sich viele der entsprechenden Probleme ebenfalls lösen lassen. Dabei werden nur die 

Methodensignaturen an die abgeleiteten Klassen weitergegeben, jedoch keine Attribute und keine 

Implementierungen der Methoden. 

Java ist nicht vollständig objektorientiert, da die Grunddatentypen (int, boolean usw.) keine Objekte (siehe auch 

unter Java-Syntax) sind. Sie werden allerdings ab Java 1.5 bei Bedarf automatisch und für den Programmierer 

transparent, mittels Autoboxing in die entsprechenden Objekttypen und umgekehrt umgewandelt. [7] 

Reflection 

Java bietet eine Reflection-API als Bestandteil der Laufzeitumgebung. Damit ist es möglich, zur Laufzeit auf 

Klassen und Methoden zuzugreifen, deren Existenz oder genaue Ausprägung zur Zeit der Programmerstellung nicht 

bekannt war. Häufig wird diese Technik im Zusammenhang mit dem Entwurfsmuster Fabrikmethode (Factory 

Method) angewandt. 

Annotationen 

Mit Java 5 hat Sun die Programmiersprache um Annotationen erweitert. Annotationen erlauben die Notation von 

Metadaten und ermöglichen bis zu einem gewissen Grad benutzerdefinierte Spracherweiterungen. Sinn der 

Annotationen ist unter anderem die automatische Erzeugung von Code und anderen in der Software-Entwicklung 

wichtigen Dokumenten für wiederkehrende Muster anhand möglichst kurzer Hinweise im Quelltext. Bislang wurden 

in Java dafür ausschließlich Javadoc-Kommentare mit speziellen JavaDoc-Tags verwendet, die von Doclets wie zum 

Beispiel dem XDoclet ausgewertet wurden. 

Annotationen können auch in den kompilierten Class-Dateien enthalten sein. Der Quelltext wird also für ihre 

Verwendung nicht benötigt. Insbesondere sind die Annotationen auch über die Reflection-API zugänglich. So 

können sie zum Beispiel zur Erweiterung des Bean-Konzeptes verwendet werden.


Modulare Ausführung auf fernen Computern 

Java bietet die Möglichkeit, Klassen zu schreiben, die in unterschiedlichen Ausführungsumgebungen ablaufen. 

Beispielsweise lassen sich Applets in Webbrowsern, die Java unterstützen, ausführen. Das Sicherheitskonzept von 

Java kann dazu eingesetzt werden, dass unbekannte Klassen dabei keinen Schaden anrichten können, was vor allem 

bei Applets wichtig ist (siehe auch Sandbox). Beispiele für in entsprechenden Ausführungsumgebungen ausführbare 

Java-Module sind Applets, Servlets, Portlets, Midlets, Xlets, Translets, und Enterprise Java Beans. 

Merkmale der Sprache 

Der Objektzugriff in Java ist über Referenzen implementiert. Aus Sicherheitsgründen ist es nicht möglich, deren 

Speicheradresse zu modifizieren. So genannte Zeigerarithmetik ist mit der Sprache also ausgeschlossen. Per Design 

kann so ein häufiger Typ von Fehlern, die in anderen Programmiersprachen auftreten, von vornherein 

ausgeschlossen werden. 

Zusammengehörige Klassen werden in Paketen (englisch packages) zusammengefasst. Diese Pakete ermöglichen die 

Einschränkung der Sichtbarkeit von Klassen, eine Strukturierung von größeren Projekten sowie eine Trennung des 

Namensraums für verschiedene Entwickler. Die Paketnamen sind hierarchisch aufgebaut und beginnen meist mit 

dem (umgekehrten) Internet-Domainnamen des Entwicklers. (Pakete, die von Sun erstellt werden, beginnen z. B. mit 

„com.sun.“) Klassennamen müssen nur innerhalb eines Paketes eindeutig sein. Hierdurch ist es möglich, Klassen von 

verschiedenen Entwicklern zu kombinieren, ohne dass es zu Namenskonflikten kommt. Die Hierarchie der 

Paketnamen hat allerdings keine semantische Bedeutung. Bei der Sichtbarkeit zwischen den Klassen zweier Pakete 

spielt es keine Rolle, wo sich die Pakete in der Namenshierarchie befinden. Klassen sind entweder nur für Klassen 

des eigenen Paketes sichtbar oder für alle Pakete. 

Weiter unterstützt die Sprache Threads (nebenläufig ablaufende Programmteile) und Ausnahmen (englisch 

exception). Java beinhaltet auch eine automatische Speicherbereinigung (englisch garbage collector), die nicht 

(mehr) referenzierte Objekte aus dem Speicher entfernt. 

Java unterscheidet explizit zwischen Schnittstellen und Klassen. Eine Klasse kann beliebig viele Schnittstellen 

implementieren, hat aber stets genau eine Basisklasse. Java unterstützt kein direktes Erben von mehreren Klassen 

(sogenannte „Mehrfachvererbung“), jedoch die Vererbung über mehrere Hierarchie-Ebenen (Klasse Kind erbt von 

Klasse Vater, die ihrerseits von Klasse Großvater erbt usw.). Je nach Sichtbarkeit (public, protected, 

default/package-private, private) erbt die Klasse Methoden und Attribute (auch Felder genannt) von ihren 

Klassenvorfahren. Alle Klassen sind – direkt oder indirekt – von der Wurzelklasse Object abgeleitet. 

Zu Java gehört eine umfangreiche Klassenbibliothek. Dem Programmierer wird damit eine einheitliche, vom 

zugrunde liegenden Betriebssystem unabhängige Schnittstelle (Application programming interface, API) angeboten. 

Mit Java 1.2 wurden die Java Foundation Classes (JFC) eingeführt, die unter anderem Swing bereitstellen, das zur 

Erzeugung plattformunabhängiger grafischer Benutzerschnittstellen (GUI) dient und auf AWT basiert. 

Syntax 

Hauptartikel: Java-Syntax 

Syntax/Grammatik und Semantik von Java sind in der Java Language Specification (Java-Sprachspezifikation) von 

Sun Microsystems dokumentiert. Das folgende Beispielprogramm gibt die unter Programmierern klassische 

Meldung „Hallo Welt!“ auf dem Ausgabemedium aus. 

public class HalloWelt { 

public static void main(String[] args) { 

} 

System.out.println("Hallo Welt!");


} 

Entstehung und Weiterentwicklung der Sprache 

Entstehung 

Herkunft und Entwicklung der Programmiersprache Java sowie mit ihr verwandter Technik sind im Artikel Java 

(Technik) beschrieben. 

Sun und JCP 

Neben Sun kümmert sich eine Vielzahl von Einzelpersonen, kleiner und großer Unternehmen, wie Apple, IBM, 

Hewlett-Packard und Siemens beim Java Community Process (JCP) unter anderem um die Weiterentwicklung der 

Java-Sprachspezifikation. Der JCP wurde 1998 von Sun Microsystems ins Leben gerufen. 

Java als freie Software 

Sun hat zugesichert, sein JDK unter der GNU General Public License zu veröffentlichen. Am 13. November 2006 

wurden bereits mit dem Compiler javac und der Hotspot Virtual Machine erste Teile als Open Source veröffentlicht. 

Zudem wurde mit OpenJDK eine Community-Seite eröffnet, mit deren Hilfe die Entwicklung koordiniert werden 

soll. [8] Am 8. Mai 2007 folgten dann große Teile des „Java SE“-Quellcodes zum Erstellen eines JDK. Eine 

Ausnahme stellt solcher Code dar, für den Sun nicht die nötigen Rechte besitzt, um ihn freizugeben. Dieser liegt 

somit nur in kompilierter Form vor. [9] Ebenfalls kündigte Sun an, dass Entwicklungen auf Grundlage des OpenJDK 

das „Java Compatible“-Logo führen dürfen, wenn sie nach dem „Technical Compatibility Kit“ (JCK) zertifiziert sind. 

Zuvor wurde der Quelltext von Java unter anderem bei jedem JDK mitgeliefert und ermöglichte so zwar Einsicht, er 

durfte aber nicht beliebig modifiziert werden. Deswegen gibt es neben den offiziellen JCP auch diverse unabhängige 

Vereinigungen, die es sich zum Ziel gesetzt haben, ein unter eine freie Open-Source-Lizenz gestelltes Java 

bereitzustellen. Die bekanntesten dieser Projekte sind Apache Harmony, Kaffe und das GNU-Classpath-Projekt. 

Unterschiede zu ähnlichen Sprachen 

JavaScript 

Java ist nicht mit der Skriptsprache JavaScript zu verwechseln, die vornehmlich in HTML-Seiten zur eingebetteten 

Programmierung verwendet wird, um interaktive Webapplikationen zu ermöglichen. Sie ist eine dynamisch 

typisierte, objektorientierte, aber klassenlose Skriptsprache mit einer ähnlichen Syntax wie Java, unterscheidet sich 

jedoch in vielerlei Hinsicht von Java. 

Smalltalk 

Smalltalk ist eine der ältesten objektorientierten Programmiersprachen überhaupt. Java erbt von Smalltalk die 

grundsätzliche Konzeption eines Klassenbaumes, in den alle Klassen eingehängt werden. Dabei stammen alle 

Klassen entweder direkt oder indirekt von der Klasse java.lang.Object ab. Außerdem wurden die Konzepte der 

automatischen Speicherbereinigung (garbage collector) und der virtuellen Maschine übernommen sowie eine 

Vielzahl weiterer Merkmale der Sprache Smalltalk. 

Smalltalk kennt jedoch keine primitiven Datentypen wie zum Beispiel int – selbst eine einfache Zahl ist ein Objekt. 

Dieses Konzept wurde nicht nach Java übernommen, primitive Datentypen werden aber ab Java 1.5 mittels 

Autoboxing bei Bedarf in die entsprechenden Objekttypen und umgekehrt umgewandelt. [7]


C++ 

Java lehnt seine Syntax an die der Programmiersprache C++ an. Im Gegensatz zu C++ fanden jedoch komplexe 

Konstrukte wie Mehrfachvererbung oder die fehleranfällige Zeigerarithmetik keinen Einzug. Klassen können nur 

eine Superklasse haben (Einfachvererbung), aber eine beliebige Anzahl von Interfaces implementieren. Interfaces 

entsprechen abstrakten Klassen in C++, welche keine Attribute oder konkrete Methoden besitzen, werden allerdings 

konzeptionell anders als die auch in Java möglichen abstrakten Klassen verwendet. Die interne Speicherverwaltung 

wird dem Java-Entwickler weitgehend abgenommen; dies erledigt die automatische Speicherbereinigung. Deshalb 

ist Java in vielen Fällen leichter zu handhaben als C++. Allerdings garantiert auch dieser Mechanismus nicht den 

vollständigen Ausschluss von Speicherlecks. Letztlich muss der Programmierer dafür sorgen, dass nicht mehr 

verwendete Objekte nirgends mehr referenziert werden. 

Neben Mehrfachvererbung und Speicherarithmetik wurden bei der Entwicklung von Java noch weitere Konstrukte 

der Sprache C++ bewusst weggelassen: 

Im Gegensatz zu C++ ist es in Java nicht möglich, Operatoren (zum Beispiel arithmetische Operatoren wie + und -, 

logische Operatoren wie && und ||, oder den Index-Operator []) zu überladen, das heißt in einem bestimmten 

Kontext mit neuer Bedeutung zu versehen. Dies sorgt einerseits für eine Vereinfachung der Sprache an sich und 

verhindert, dass Quellcodes mit Operatoren, die mit schwer nachvollziehbarer Semantik überladen werden, 

unleserlich gemacht werden. Andererseits würden benutzerdefinierte Typen mit überladenen Operatoren in C++ eher 

wie eingebaute Typen erscheinen können – vor allem numerischer Code wäre so mitunter einfacher 

nachzuvollziehen. Die Sprachdefinition von Java definiert jedoch typabhängiges Verhalten der Operatoren + 

(Addition bei arithmetischen Operanden, andernfalls zur Verkettung von Zeichenketten sog. „string concatenation“) 

sowie &, | und ^ (logisch für boolean und bitweise für arithmetische Operanden). Das lässt diese Operatoren 

zumindest wie teilweise überladene Operatoren erscheinen. 

Das C++-Konstrukt der „Templates“, die es erlauben, Algorithmen oder sogar ganze Klassen unabhängig von den 

darin verwendeten Datentypen zu definieren, wurde in Java nicht übernommen. Seit Version 1.5 unterstützt Java 

aber sogenannte „Generics“, die zwar keinerlei Metaprogrammierung erlauben, aber ähnlich wie C++-Templates 

typsichere Container und ähnliches ermöglichen. 

In Java wurde das Schlüsselwort const reserviert, hat aber keine Funktion. Die Alternative zu const (und 

Präprozessor-Direktiven) ist final. Im Gegensatz zu const wird final in einer Methodensignatur nicht vererbt und hat 

somit nur im aktuellen Scope Gültigkeit. Den final-Modifikator kann eine Klasse (die dadurch nicht mehr abgeleitet 

werden kann), ein Attribut (dessen Wert so nur einmal gesetzt werden kann) oder eine Methode (die dadurch 

unüberschreibbar wird) besitzen. 

C# 

Die von Microsoft entwickelte Programmiersprache C# kann als Konkurrenzprodukt zu Java gesehen werden. Mit 

der Spezifikation von C# hat Microsoft im Rahmen seiner .NET-Strategie versucht, den Spagat zwischen der 

Schaffung einer neuen Sprache und der leichten Integration bestehender Komponenten zu schaffen. 

Konzeptionelle Unterschiede zu Java bestehen insbesondere in der Umsetzung von Callback-Mechanismen. C# 

implementiert hierzu die Unterstützung von Delegaten (engl. delegates), einem Konzept, das mit Funktionszeigern 

vergleichbar ist. In Java kommt hingegen das Beobachter-Entwurfsmuster zum Einsatz. 

Des Weiteren unterstützt C# sogenannte Attribute (attributes), die es erlauben, die Funktionalität der Sprache über 

Metadaten im Code zu erweitern (eine ähnliche Funktionalität wurde in Form der oben beschriebenen Annotations in 

Java 5.0 übernommen). C# enthält auch Bestandteile der Sprachen VisualBasic, zum Beispiel Eigenschaften 

(„properties“), sowie Konzepte aus C++. 

In C# ist es ebenso wie in Java möglich, Ausnahmen (exceptions) zu einer Methode zu deklarieren. In Java können 

Ausnahmen so deklariert werden, dass sie auch verarbeitet werden müssen (checked Exception).


Systembefehle können in .NET über platform invoke aufgerufen werden. Dies ist in Java von der Syntax her nicht 

möglich, kann aber über die Klassenbibliothek mittels Runtime.exec() und java.lang.ProcessBuilder 

beziehungsweise Jakarta Commons Exec bewerkstelligt werden. 

Geschwindigkeitskritische Programmteile können in C# in sogenanntem unsicheren unsafe code geschrieben 

werden, was ähnlich zu Inline-Assembler in C-Programmen zu sehen ist. Java kennt hierfür in der Sprache aus 

Sicherheits-, Stabilitäts- und Pattformunabhängigkeitsgründen keine Entsprechung. Java bietet allerdings mittels 

Java Native Interface die Möglichkeit, C und C++ Code in Javapakete einzubetten und außerhalb der Java Virtual 

Machine laufen zu lassen. Darüberhinaus bietet Java die Möglichkeit aus Java Code heraus verschiedene 

Skriptsprachen auszuführen. Ebenfalls gibt es eine Reihe an Programmiersprachen, welche nach Java Bytecode 

kompiliert werden. Damit lassen sich Programmteile auch in anderen Programmiersprachen umsetzen. Im JDK 

Version 7, das etwa im September 2010 erwartet wird, [10] ist auch eine Unterstützung für dynamische 

„Fremdsprachen“ durch die Virtual Machine vorgesehen. [11] 


Es gibt eine große Vielfalt von Entwicklungsumgebungen für Java, sowohl kommerzielle als auch freie (Open 

Source). Die meisten Entwicklungsumgebungen für Java sind selbst ebenfalls in Java geschrieben. 

Die bekanntesten Open-Source-Umgebungen sind das von der Eclipse Foundation bereitgestellte Eclipse und das 

von Sun entwickelte NetBeans. 

Unter den kommerziellen Entwicklungsumgebungen sind das auf NetBeans basierende Sun ONE Studio von Sun, 

IntelliJ IDEA von JetBrains, JBuilder von Borland sowie JCreator am verbreitetsten. Außerdem gibt es noch eine, 

um einige hundert Plugins erweiterte Version von Eclipse, die von IBM unter dem Namen WebSphere Studio 

Application Developer („WSAD“) vertrieben wurde und seit Version 6.0 Rational Application Developer („RAD“) 

heißt. 

Apple liefert mit Mac OS X ab Version 10.3 die Entwicklungsumgebung Xcode aus, die verschiedene 

Programmiersprachen unterstützt und einen Schwerpunkt auf Java setzt. Xcode wird mit jedem Apple 

(-Betriebssystem) mitgeliefert, Aktualisierungen sind darüber hinaus nach Registrierung für jedermann kostenlos 

erhältlich. 

Wer lieber einen Texteditor verwendet, findet in Emacs zusammen mit der JDEE (Java Development Environment 

for Emacs) ein mächtiges Werkzeug. Ein vielseitiger und erweiterbarer in Java geschriebener Editor ist jEdit. Für 

andere Editoren wie Vim, Jed oder Textpad gibt es ebenfalls entsprechende Modi. 

Compiler 

Ein Java-Compiler übersetzt Java-Quellcode (Dateiendung .java) in einen ausführbaren Code. Grundsätzlich 

unterscheidet man zwischen Bytecode- und Nativecode-Compilern. Einige Java-Laufzeitumgebungen verwenden 

einen JIT-Compiler, um zur Laufzeit den Bytecode häufig genutzter Programmteile in nativen Maschinencode zu 

übersetzen. 

Bytecode-Compiler 

Im Normalfall übersetzt der Java-Compiler die Programme in einen nicht direkt ausführbaren Bytecode 

(Dateiendung .class), den die Java Runtime Environment (JRE) später ausführt. Die aktuelle HotSpot-Technologie 

kompiliert den Bytecode zur Laufzeit in nativen Prozessorcode und optimiert diesen abhängig von der verwendeten 

Plattform. Diese Optimierung findet dabei nach und nach statt, so dass der Effekt auftritt, dass Programmteile nach 

mehrmaliger Abarbeitung schneller werden. Andererseits führt diese Technik, die ein Nachfolger der 

Just-In-Time-Compilierung ist, dazu, dass Java-Bytecode theoretisch genau so schnell wie native, kompilierte 

Programme ausgeführt werden könnte.


Die HotSpot-Technik ist seit der JRE Version 1.3 verfügbar und wurde seitdem stetig weiter verbessert. 

Beispiele für Bytecode-Compiler sind javac (Teil des JDKs) und Jikes von IBM. 

Native Compiler 

Es existieren auch Compiler für Java, die Java-Quelltexte oder Java-Bytecode in normalen Maschinencode 

übersetzen können, sogenannte Ahead-of-time-Compiler. Nativ kompilierte Programme haben den Vorteil, keine 

JavaVM mehr zu benötigen, aber auch den Nachteil, nicht mehr plattformunabhängig zu sein. 

Beispiele für native Java Compiler sind Excelsior JET sowie GNU Compiler for Java (GCJ) wie MinGW, Cygwin 

oder JavaNativeCompiler (JNC). 

Wrapper 

Als weitere Möglichkeit kann das Java-Programm in ein anderes Programm „eingepackt“ (englisch to wrap) werden; 

diese äußere Hülle dient dann als Ersatz für ein Java Archive. Sie sucht selbständig nach einer installierten 

Java-Laufzeitumgebung, um das eigentliche Programm zu starten, und informiert den Benutzer darüber, wo er eine 

Laufzeitumgebung herunterladen kann, sofern noch keine installiert ist. Es ist also immer noch eine 

Laufzeitumgebung nötig, um das Programm starten zu können, aber der Anwender erhält eine verständliche 

Fehlermeldung, die ihm weiterhilft. 

Java Web Start ist ein etwas eleganterer und standardisierter Ansatz für diese Lösung – er ermöglicht die einfache 

Aktivierung von Anwendungen mit einem einzigen Mausklick und garantiert, dass immer die neueste Version der 

Anwendung ausgeführt wird. Dadurch werden komplizierte Installations- oder Aktualisierungsprozeduren 

automatisiert. 

Beispiele für Java Wrapper sind JSmooth oder Launch4J. JBuilder von Borland und NSIS sind ebenfalls in der Lage, 

einen Wrapper für Windows zu erstellen. 

Literatur 

• Guido Krüger: Handbuch der Java-Programmierung. [12] 6. Auflage. Addison Wesley, 2009, ISBN 

978-3-8273-2874-8 

• James Gosling, Bill Joy, Guy Steele, Gilad Bracha: The Java Language Specification. Third Edition. 

Addison-Wesley 2005, ISBN 0-321-24678-0 (online [13] ) 

• Christian Ullenboom: Java ist auch eine Insel. [14] 8. Auflage. Galileo Computing, 2009, ISBN 

978-3-8362-1371-4 

• Gottfried Wolmeringer: Java 6 lernen mit Eclipse, Galileo Computing, ISBN 3-89842-872-9 

• Dirk Louis, Peter Müller: Java 5 Kompendium – Praxis der objektorientierten Programmierung. Markt & 

Technik, 2005, ISBN 3-8272-6844-3 

• Hubert Partl, Uni Wien: Programmieren mit Java (Onlineversion [15] )


Weblinks 

• Java-Abteilung von Sun Microsystems [3] (englisch) 

• Java-Download [16] 

• java.net Java-community [17] Projekte-Blogs etc. (englisch) 

• Programmierrichtlinien für Java [18] von Sun Microsystems (englisch) 

• Kenndaten JDK 7 (englisch) [19] 

Referenzen 

[1] Jon Byous: Java Technology: The Early Years. (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html) Sun Microsystems, 2003, „On May 

23, 1995, John Gage, director of the Science Office for Sun Microsystems, and Marc Andreessen, cofounder and executive vice president at 

Netscape, stepped onto a stage and announced to the SunWorldTM audience that JavaTM technology was real, it was official, and it was 

going to be incorporated into Netscape NavigatorTM, the world's portal to the Internet.“, abgerufen am 22. Dezember 2009 (Englisch). 

[2] Java 5 catches up with C# (http:/ / www. barrycornelius. com/ papers/ java5/ onefile/ ) 

[3] http:/ / java. sun. com/ 

[4] The Java Language Environment – 1.2 Design Goals of the JavaTM Programming Language (http:/ / java. sun. com/ docs/ white/ langenv/ 

Intro. doc2. html), James Gosling und Henry McGilton, Mai 1996 

[5] Java Language Overview (http:/ / java. sun. com/ docs/ overviews/ java/ java-overview-1. html), 1995 Sun Whitepaper 

[6] C.A.R. Hoare: Monitors: An Operating System Structuring Concept, Comm. ACM 17, 10:549–557 (Oktober 1974) 

[7] Autoboxing in Java (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ autoboxing. html) 

[8] Community-Seite zur Entwicklung des Open-Source-JDKs von Sun (https:/ / openjdk. dev. java. net/ ) 

[9] Sun Microsystems Presseankündigung vom 8. Mai 2007 (http:/ / www. sun. com/ aboutsun/ pr/ 2007-05/ sunflash. 20070508. 3. xml) 

[10] http:/ / openjdk. java. net/ projects/ jdk7/ Roadmap JDK 7 

[11] JDK 7 Features – JSR 292: VM support for non-Java languages (InvokeDynamic) (http:/ / openjdk. java. net/ projects/ jdk7/ features/ #f353) 

[12] http:/ / www. javabuch. de 

[13] http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html 

[14] http:/ / openbook. galileocomputing. de/ javainsel8/ 

[15] http:/ / www. boku. ac. at/ javaeinf/ EinfProgJava. pdf 

[16] http:/ / java. com/ de/ download/ index. jsp 

[17] http:/ / java. net 

[18] http:/ / java. sun. com/ docs/ codeconv/ html/ CodeConvTOC. doc. html 

[19] http:/ / openjdk. java. net/ projects/ jdk7/ features/

JavaScript 69 

JavaScript 

JavaScript 

Paradigmen: multiparadigmatisch 


Entwickler: Brendan Eich 


Typisierung: schwach, dynamisch, duck 

wichtige Implementierungen: SpiderMonkey, Rhino, SquirrelFish, 

V8 

Einflüsse: Self, C, Scheme, Perl, Python, Java 

JavaScript ist eine Skriptsprache, die hauptsächlich für das DOM-Scripting in Web-Browsern eingesetzt wird. 

Der als ECMAScript (ECMA 262) standardisierte Sprachkern von JavaScript beschreibt eine moderne, schlanke, 

dynamisch typisierte, objektorientierte, aber klassenlose Skriptsprache, die dennoch allen objektorientierten 

Programmierparadigmen unter anderem auch – aber eben nicht ausschließlich – auf der Basis von Prototypen 

gerecht wird. In JavaScript lässt sich objektorientiert und sowohl prozedural als auch funktional programmieren. 

Während HTML/CSS nur rudimentäre Möglichkeiten zur Nutzerinteraktion bietet, können mit JavaScript Inhalte 

generiert und nachgeladen werden. 

Entwicklung 

Die Syntax von JavaScript ähnelt jener der C-Abkömmlinge, wozu auch Java gehört. Trotz der Namens- und 

syntaktischen Ähnlichkeit hat JavaScript nur geringe Gemeinsamkeiten mit Java, beispielsweise wird 

Objektorientierung in JavaScript anders als in Java nicht durch Klassen, sondern durch Prototypen unterstützt. 

Von Brendan Eich zuerst Mocha genannt, wurde die Sprache aus Marketinggründen erst in LiveScript und 

letztendlich in JavaScript umbenannt: Um dem damals aktuellen Java-Trend zu entsprechen, entstand mit 

LiveConnect eine Schnittstelle zwischen Java und LiveScript, was sich im neuen Namen JavaScript ausdrücken 

sollte. [1] JavaScript ist eine Marke des Unternehmens Sun Microsystems. [2] 

Ursprünglich für den Netscape Navigator entwickelt, finden sich heute nach dem sogenannten Browserkrieg 

mittlerweile in praktisch allen grafischen Browsern weitgehend kompatible JavaScript-Interpreter wie z. B. 

SpiderMonkey für Mozilla/Gecko oder JScript von Microsoft. Der Sprachkern von JavaScript ist unter dem Namen 

ECMAScript durch Ecma International standardisiert. Der in Java implementierte JavaScript-Interpreter Rhino wird 

ab Version 6.0 als Teil der Java-Laufzeitumgebung standardmäßig mitgeliefert. [3] 

Inzwischen hat sich die Sprache auch neue Anwendungsgebiete erschlossen. Zum Beispiel wird sie gerne als 

Skriptsprache für Spiele und Anwendungsprogramme eingesetzt, da der Sprachkern nur wenige Objekte enthält und 

dadurch der zur Ausführung von in JavaScript formulierten Skripten erforderliche Interpreter relativ klein gehalten 

werden kann.

JavaScript 70 

Überblick 

JavaScript wird hauptsächlich clientseitig eingesetzt, im Unterschied zu anderen im Web verwendeten Sprachen, wie 

Perl oder PHP, die ausschließlich serverseitig eingesetzt werden. JavaScript bzw. die 

ECMAScript-Implementationen finden jedoch beispielsweise auf Netscape Enterprise Servern (NES), und als 

JScript bzw. JScript.NET in einer ASP- bzw. ASP.NET-Umgebung auf Microsoft Internet Information Services auch 

serverseitig Anwendung (Stichwort Server-Side JavaScript). Weitere Beispiele für serverseitige 

Javascript-Programmierung sind POW und Jaxer, die auf der Mozilla-Javascript-Engine Spidermonkey aufsetzen. 

JavaScript wurde ursprünglich von Sun Microsystems und Netscape in Kooperation entwickelt. Trotz des ähnlichen 

Namens und einer ähnlichen Syntax ist JavaScript grundlegend verschieden von der Programmiersprache Java, die 

von Sun Microsystems stammt. Die Namensgleichheit erklärt sich wohl vor allem aus der Absicht, aus 

Marketinggründen eine Verbindung mit den damals sehr populären Java-Applets herzustellen. Die Syntax wurde 

auch aus diesem Grund weitgehend der von Java angeglichen. 

Die ursprüngliche Grundfunktionalität von JavaScript ist heute als ECMAScript oder ECMA-262 standardisiert und 

wird von den meisten Browsern weitgehend unterstützt (JavaScript in der Version 1.5 entspricht ECMA-262 Version 

3). 

Typische Anwendungsgebiete 

Typische Anwendungsgebiete von JavaScript sind: 

• Plausibilitätsprüfung (Validierung) von Formulareingaben beim Absender 

• Mehrere Frames auf einmal wechseln oder die Seite aus dem Frameset „befreien“ 

• Banner oder Laufschriften 

• Dynamische Manipulation von Webseiten über das Document Object Model 

• Senden und Empfangen von Daten, ohne dass der Browser die Seite neu laden muss (Ajax) 

• sofortiges Vorschlagen von Suchbegriffen 

• Verschleierung von E-Mail-Adressen zur Bekämpfung von Spam (siehe den betreffenden Artikel). 

Missbrauch 

Einige Anwendungen, die mit JavaScript möglich sind, verärgern meistens den Benutzer und werden als „schlechter 

Stil“ angesehen: 

• Quelltext „verschleiern“, um diesen vor dem Besucher zu verstecken 

• Verschleiern von Internetadressen, auf die ein Link verweist 

• Deaktivieren des Kontextmenüs, um zu erschweren, dass Bilder oder die gesamte Seite abgespeichert werden 

können 

• Deaktivieren der Kopierfunktion, um zu erschweren, dass Texte oder Bilder kopiert werden können 

• Unaufgeforderte (Werbe-)Pop-ups oder Pop-unders 

• Ungewolltes Öffnen von Fenstern, teilweise auch Öffnen beliebig vieler Fenster 

• Ungewolltes Schließen des Browserfensters 

• Ungewollte Größenänderung des Browserfensters 

• Blockieren der Anwender mit zahllosen aufeinanderfolgenden Dialogfenstern 

• Bei anfälligen Webanwendungen kann JavaScript auch von Dritten missbraucht werden, etwa per XSS 

(Codeeinschleusung). 

• JavaScript-Navigation: Barrierearme Webseiten zeichnen sich dadurch aus, dass sie auch bei abgeschaltetem 

JavaScript möglichst uneingeschränkt navigierbar bleiben. Oft schränkt das nicht aktivierte JavaScript die 

Benutzbarkeit einer Webseite ein.

JavaScript 71 

Geschichte 

Am 18. September 1995 veröffentlicht Netscape mit der Vorversion des Navigator 2.0 einen Browser mit einer 

eingebetteten Skriptsprache, die zu diesem Zeitpunkt LiveScript heißt und von Brendan Eich entwickelt wurde. Die 

Sprache kann u. a. Formulareingaben des Benutzers vor dem Absenden überprüfen. Am 4. Dezember 1995 

verkünden Netscape und Sun Microsystems eine Kooperation die die Interaktion von LiveScript direkt mit 

Java-Applets zum Ziel hat. Sun entwickelte die nötigen Java-Klassen, Netscape die Schnittstelle LiveConnect und 

benennt die Sprache in JavaScript um (JavaScript 1.0). 

Mit der ersten Beta-Version des Navigator 3.0 führt am 29. April 1996 Netscape JavaScript 1.1 ein. Neu ist die 

Möglichkeit, auf Bilder zuzugreifen und so genannte Rollover-Grafiken zu erstellen. LiveConnect ist jetzt 

Bestandteil des Browsers. Mit der Beta-Version des Internet Explorer 3 stellt im Mai 1996 Microsoft seinen ersten 

JScript-fähigen Browser vor. Beginn des Browserkriegs. Mit der Ankündigung des Netscape Communicators wird 

JavaScript 1.2 am 15. Oktober 1996 veröffentlicht, der Netscape Communicator 4.0 mit JavaScript 1.2 erscheint 

jedoch erst am 4. Juni 1997. Ebenfalls im Juni 1997 veröffentlicht die European Computer Manufacturers 

Association ihren Standard ECMA-262 (ECMAScript), der zusammen mit Netscape entwickelt wurde und die 

Grundelemente einer Skriptsprache standardisieren soll. Diese wird im April 1998 zur ISO-Norm ISO/IEC 

16262:1998 Information technology – ECMAScript language specification. Am 1. Oktober 1997 kommt der Internet 

Explorer 4 heraus, der den Sprachumfang von JavaScript 1.1 abdeckt. Darüber hinaus werden eigene Erweiterungen 

veröffentlicht, die zu Kompatibilitätsunterschieden zwischen Navigator und Internet Explorer führen und eine 

DOM-ähnliche Syntax zur Verfügung stellen, die es ermöglicht, auf alle Elemente der Webseite zuzugreifen und 

diese beliebig zu verändern. 

Im Juli 1998 kommt mit der Beta-Version des Netscape Communicators 4.5 JavaScript 1.3. Erstmals zu finden war 

diese JavaScript-Version schon in der Version 4.06 des Netscape Communicators. 

Im Oktober 1998 stellt Netscape JavaScript 1.4 vor. Diese Version ist vollständig kompatibel mit ECMA-262. Ein 

Browser mit der Unterstützung dieser Version erscheint jedoch nicht. 

Im April 2000 kommt mit der Preview Release 1 des Navigator 6 JavaScript 1.5 und DOM Level 1. Am 5. Juni 2002 

erscheint Mozilla 1.0 mit JavaScript 1.5, am 29. November 2005 Mozilla Firefox 1.5 mit JavaScript 1.6, am 12. Juli 

2006 Mozilla Firefox 2.0b1 mit JavaScript 1.7. und am 18. Dezember 2007 Mozilla Firefox 3.0b2 mit JavaScript 1.8. 

Versionsgeschichte 

Versionsgeschichte von JavaScript [4] 

Version Release Entsprechung Netscape 

Navigator 

Mozilla 

Firefox 

1.0 März 1996 2.0 3.0 

1.1 August 1996 3.0 

1.2 Juni 1997 4.0-4.05 

1.3 Oktober 1998 ECMA-262 1 st edition / ECMA-262 

2 nd edition 

1.4 Netscape Server 

4.06-4.7x 4.0 

Internet 

Explorer 

Opera Safari Google 

Chrome

JavaScript 72 

1.5 November 

2000 

1.6 November 

2005 

ECMA-262 3 rd edition 

1.5 + Array extras + Array & String 

generics + E4X 

1.7 Oktober 2006 1.6 + Pythonic generators + Iterators 

+ let 

1.8 Juni 2008 1.7 + Generator expressions + 

Expression closures 

1.8.1 1.8 + geringfügige Updates 3.5 

1.9 1.8.1 + ECMAScript 5 Compliance 4 

Sicherheit 

Das Sandbox-Prinzip 

6.0 1.0 • 5.5 (JScript 

5.5) 

• 6 (JScript 

5.6) 

• 7 (JScript 

5.7) 

• 8 (JScript 6) 

• 6.0 

• 7.0 

• 8.0 

• 9.0 

1.5 • 3.0 

• 3.1 

2.0 • 3.2 

JavaScript wird im Browser in einer so genannten Sandbox ausgeführt. Dieses bewirkt, dass man in JavaScript im 

Allgemeinen nur Zugriff auf die Objekte des Browsers hat und somit nicht auf das Dateisystem zugreifen und damit 

Dateien lesen oder schreiben kann. Es ist jedoch zumindest in JScript möglich, bei entsprechenden 

Sicherheitseinstellungen durch die Nutzung von ActiveX diese Beschränkungen zu umgehen. 

Zusätzlich wird jeder Webauftritt oder Webapplikation isoliert behandelt und ein Datenaustausch wird unterbunden. 

Das ist wichtig, um Sicherheitsprobleme zu verhindern. Ohne diese Isolierung wäre es beispielsweise möglich, dass 

eine böswillige Seite Bankdaten abgreifen könnte, wenn beide Webpräsenzen zur selben Zeit betrachtet werden. 

Es bewirkt ferner, dass Aktionen wie das Schließen des Browserfensters, das Aus- und Einblenden von 

Symbolleisten, das Ändern der im Browser eingestellten Startseite oder das Auslesen der zuletzt besuchten 

Webseiten des Anwenders die explizite Erlaubnis des Benutzers erfordern. 

Deaktivieren von JavaScript 

In fast allen JavaScript-fähigen Browsern lässt sich JavaScript abschalten oder lassen sich einzelne Aktionen, wie die 

Änderung des Textes in der Statusleiste oder die Manipulation von Browserfenstern, deaktivieren. Da diese 

Einstellungen jedoch bei einigen Browsern sehr umständlich oder versteckt sind, wurden dafür auch 

Zusatzprogramme, wie z.B. NoScript, entwickelt, mit denen sich solche Browser nachrüsten lassen. 

Sprachelemente 

Datentypen 

Der Datentyp einer Variablen v lässt sich mit typeof v ermitteln. 

Zeichenketten haben den Typ string, numerische Werte den Typ number und boolesche Werte den Typ boolean. Ein 

Sonderfall ist der Typ undefined mit undefined als einzigem Wert. Funktionen sind Objekte, der typeof-Operator 

gibt als Typ aber function zurück. Alle anderen Werte - reguläre Ausdrücke, Arrays und der Wert null inbegriffen - 

sind vom Typ object. 

Mit den vordefinierten Konstruktorfunktionen String, Number, Boolean erstellte Variablen verhalten sich wie Werte 

der entsprechenden Datentypen - der typeof-Operator gibt jedoch "object" zurück: 

3.0 

• 4.0 

1.0

JavaScript 73 

var variable = "Beispieltext"; 

alert(typeof variable); // ergibt "string" 

variable = new String("Beispieltext"); 

alert(typeof variable); // ergibt "object" 

Umgekehrt werden Variablen der primitiven Typen number, boolean und string bei Bedarf automatisch in Objekte 

der entsprechenden Konstruktorfunktion umgewandelt: 

var variable = "Beispieltext"; 

alert(variable.length); // ergibt 12 

JavaScript ist dynamisch typisiert, d. h. der Datentyp einer Variablen kann sich während der Ausführung eines 

Scripts ändern, was manchmal zu Fehlern bzw. unerwünschten Effekten führt. 

Kontrollstrukturen 

If … else (Bedingte Anweisung) 

if (bedingung) { 

} else { 

} 

anweisungen; 

anweisungen; 

Switch-Kontrollstruktur 

switch (variable) { 

} 

While-Schleife 

case wert1 : 

anweisungen; 

break; 

case wert2 : 

default : 

anweisungen; 

break; 

anweisungen; 

while (bedingung) { 

} 

anweisungen; 

Do-while-Schleife 

do { 

anweisungen; 

} while (bedingung);

JavaScript 74 

For-Schleife 

for (startausdruck; bedingung; iterationsausdruck) { 

} 

anweisungen; 

For … in-Schleife 

Mit dieser Anweisung werden alle eigenen und ererbten Eigenschaften eines Objektes durchlaufen, die nicht die 

interne Eigenschaft DontEnum aufweisen. DontEnum gilt für bestimmte eingebaute Eigenschaften und kann nicht 

vom Benutzer gesetzt werden. [5] Bei jedem Schleifendurchgang wird einer angegebenen Variable der 

Eigenschaftsname zugewiesen. 

for (var eigenschaftsname in objekt) { 

} 

anweisungen; 

For Each … in-Schleife 

Die For Each … in-Schleife gleicht der For … in-Schleife, mit dem Unterschied, dass die Eigenschaftswerte des 

Objekts durchlaufen werden und nicht deren Namen. Sie ist erst ab JavaScript 1.6 verfügbar. [6] 

for each (var eigenschaftswert in objekt) { 

} 

anweisungen; 

Geltungsbereich von Variablen 

Variablen sind in JavaScript innerhalb der Funktion sichtbar, in der sie deklariert wurden. 

Außerhalb von Funktionen deklarierte Variablen sind Eigenschaften des globalen Objekts (window). 

Funktionen 

Funktionen sind in JavaScript vollwertige Objekte. Sie haben Methoden und Eigenschaften, können erstellt und 

überschrieben, als Argumente an Funktionen übergeben und von ihnen erzeugt und zurückgegeben werden. 

Im letzteren Fall entsteht eine Closure (auch Funktionsabschluss genannt), mit der beispielsweise Datenkapselung 

umgesetzt werden kann: 

var temp = function () { 

} 

var geheimnis = 42; 

return function () { 

}; 

return geheimnis; 

var geheimnisträger = temp(); //geheimnisträger ist die von temp() 

zurückgegebene Funktion 

alert(typeof geheimnis ); // undefined 

alert(geheimnisträger()); // 42 

Nicht jedes Argument einer Funktion muss beim Aufruf angegeben werden, für fehlende Argumente wird der Wert 

undefined gesetzt. Außerdem kann innerhalb der Funktion auch über das arguments-Objekt auf die Argumente 

zugegriffen werden.

JavaScript 75 

Erzeugung 

Es gibt mehrere Möglichkeiten, in JavaScript Funktionen zu erzeugen [7] : 

// 1: Funktionsdeklaration, a ist eine Funktion mit dem Namen a. 

function a (Parameter1, Parameter2, Parameter3) { 

} 

anweisungen; 

return ausdruck; 

// 2: Funktionsausdruck ('function expression') 

// 2.1: Normalfall, b ist eine anonyme Funktion 

var b = function (...) {...} 

// 2.2: benannter Funktionsausdruck ('named function expression') 

// c ist hier eine Funktion mit dem Namen d. Außerhalb der 

// Funktion ist sie mit c ansprechbar, innerhalb mit c und d. 

var c = function d (...) {...} 

// 3: Function-Konstruktor 

var e = new Function('arg1', 'arg2', 'return arg1 + arg2'); 

// 4: 'expression closure' aus JavaScript 1.8, ähnlich dem 

Lambda-Kalkül 

// kommt ohne geschweifte Klammern und return aus, gibt das Ergebnis 

von Ausdruck zurück 

function f (...) ausdruck; 

Eine funktionale Implementation des Euklidischen Algorithmus in der rekursiven Variante sähe so aus (JavaScript 

1.8): 

// einfache Version 

function euklid (a, b) 

b ? euklid(b, a%b) : a 

// Version, die beliebig viele Argumente annimmt, 

// rekursiv, funktional 

// Ablauf: 

// (1) Erzeuge ein Array aus den Argumenten von ggT 

// (2) Wenn ggT nur (noch) ein Argument hat, gib dieses zurück, wenn es 

keines hat, 0 

// (3) sonst rufe euklid mit dem ersten Argument 

// (4) und dem Ergebnis des Ergebnisses von ggT mit den Argumenten 2 

bis n auf 

function ggT () 

(function (args) 

!args[1] 

? (function () args[0] || 0) // (2) 

: (function () euklid( // (3) 

args[0],

JavaScript 76 

)) 

ggT.apply(null, args.slice(1))() // (4) 

)(Array.prototype.slice.apply(arguments)) // (1) 

ggT(4,6); // ergibt eine Funktion, die 2 zurückgibt 

// die zurückgegebene Funktion kann auch direkt ausgeführt werden: 

ggT()(); // 0 

ggT(4)(); // 4 

ggT(4,6,8,102,244)(); // 2 

Objekte 

Jedes Objekt - auch durch Literale erzeugte Objekte - erbt vom Prototyp des globalen Object-Konstruktors. 

Vordefinierte Objekte 

JavaScript kennt mehrere eingebaute Objekte, die von ECMAScript definiert werden. 

• Das namenlose globale Objekt, das alle Variablen und Objekte enthält. 

• Object als allgemeiner Prototyp, von dem alle Objekte abgeleitet sind 

• Function als Prototyp für Funktionen 

• Array als Prototyp für Arrays 

• String als Prototyp für Zeichenketten 

• Boolean als Prototyp für Boolesche Variablen 

• Number als Prototyp für Zahlen (64-Bit-Gleitkommazahlen gemäß IEEE 754) 

• Math stellt Konstanten und Methoden für mathematische Operationen bereit. Math kann nicht als Konstruktor 

dienen. 

• Date für Operationen mit Daten bzw. Zeitpunkten und Datumsformaten 

• RegExp für reguläre Ausdrücke 

Die restlichen Objekte, die beim clientseitigen JavaScript verwendet werden, entstanden historisch vor allem durch 

die Netscape-Spezifikationen (window, document usw.). Das window-Objekt selbst ist dabei de facto das globale 

Objekt, indem einfach einer Variablen window das globale Objekt zugewiesen wurde. Zahlreiche Unterobjekte von 

document wurden mittlerweile durch DOM HTML standardisiert (title, images, links, forms usw.). Aktuelle Browser 

unterstützen zudem DOM Core und andere W3C-DOM-Standards sowie Erweiterungen von Microsoft JScript. 

Zugriff auf Objekteigenschaften und -methoden 

Eigenschaften von Objekten (auch Methoden sind Eigenschaften) werden wie folgt angesprochen: 

Punkt-Notation: 

objekt.eigenschaft; 

objekt.methode([Parameter]); 

Klammer-Notation: 

objekt["eigenschaft"]; 

objekt["methode"](); 

// Eigenschaftsname, der in Punkt-Notation illegal wäre:

JavaScript 77 

objekt["methode 1"](); 

Durch die Klammer-Notation lassen sich die Eigenschaften eines Objekts beispielsweise mit der "For … in"-Schleife 

durchlaufen. 

Allen Objekten können zur Laufzeit neue Eigenschaften hinzugefügt werden: 

objekt["eigenschaft-2"] = 1; 

objekt.methodeB = function (x) { 

}; 

return typeof objekt["eigenschaft-" + x]; 

Entfernen lassen sich Eigenschaften mit dem Operator delete: 

delete objekt.eigenschaftA; 

Objektliterale 

Objekte können in JavaScript direkt anhand ihrer Eigenschaften definiert werden: 

var meinObjekt = { 

}; 

zahl: 42, 

gibZahl: function () { 

} 

return meinObjekt.zahl; 

alert(meinObjekt.gibZahl()); // 42 

Eine spezielle Notation gibt es für reguläre Ausdrücke: 

// mit Konstruktorfunktion 

(new RegExp("a")).test("ab"); // true 

// als Literal 

/a/.test("ab"); // true 

Konstruktor-Funktionen 

Eine Funktion kann dazu genutzt werden, um ein mit new erstelltes Objekt zu initialisieren. In diesem Fall spricht 

man von einem Konstruktor oder einer Konstruktor-Funktion. Innerhalb dieser Funktion kann das neue Objekt über 

die Variable this angesprochen werden. 

function MeinObjekt(x) { // Konstruktor 

} 

this.zahl = x; 

var objekt = new MeinObjekt(3); // Instanz erzeugen 

alert(objekt.zahl); // per Meldefenster ausgeben (3)

JavaScript 78 

"private" Eigenschaften 

Private Eigenschaften und Methoden sind nicht explizit Teil der Sprache. 

Mit Hilfe von Closures (siehe Funktionen) lassen sich dennoch private Eigenschaften von Objekten realisieren: 

var neue_katze = function () { 

}; 

var lebensZahl = 7; 

var maunz = function () { 

}; 

return (lebensZahl > 0) ? "miau" : "örks"; 

// gib neues objekt zurück 

return { 

}; 

toeten: function () { 

} 

var otto = neue_katze(); 

otto.toeten(); // miau 

lebensZahl -= 1; 

alert(maunz()); 

Lediglich die "toeten"-Methode von otto kennt die Variable "lebensZahl". Der Effekt gleicht dem einer privaten 

Eigenschaft, wenn alle Methoden der Katze in der erzeugenden Funktion neue_katze definiert werden. "lebensZahl" 

ist dann für alle Methoden ("privilegierte" Methoden, im Beispiel toeten) und inneren Funktionen der erzeugenden 

Funktion ("private Methoden", im Beispiel maunz) sichtbar, nicht jedoch von außen oder von nachträglich an das 

Objekt gehängten Methoden. 

Vererbung über Prototypen 

Vererbung kann in JavaScript durch Prototypen realisiert werden. Dies erfordert, dass der prototype-Eigenschaft 

einer Konstruktor-Funktion ein als Prototyp dienendes Objekt zugewiesen wird. Wenn mit der Konstruktor-Funktion 

nun ein Objekt erzeugt wird, wird beim Zugriff auf eine nicht-existierende Eigenschaft des neuen Objekts die 

entsprechende Eigenschaft des Prototypen (wenn vorhanden) zurückgegeben. Beispiel: 

var fisch = { 

}; 

augen: 2 

var Mutantenfisch = function () { 

}; 

this.augen = 3; 

Mutantenfisch.prototype = fisch; 

var blinky = new Mutantenfisch(); 

alert(blinky.augen); // 3 - eigene Eigenschaft von blinky 

delete blinky.augen; // blinkys eigene Eigenschaft wird gelöscht 

alert(blinky.augen); // 2 - blinky hat die Eigenschaft selbst nicht 

mehr, es schimmert die Eigenschaft des Prototypen durch

JavaScript 79 

Um festzustellen, ob ein Objekt eine Eigenschaft selbst besitzt, oder vom Prototypen geerbt hat, hat jedes Objekt 

(automatisch durch Vererbung von Object) die hasOwnProperty-Methode: 

blinky.hasOwnProperty('augen'); // false 

Dialogmethoden / Benutzereingaben 

Meistens erfolgt die Interaktion mit dem Benutzer über Änderungen an Inhalten des HTML-Dokuments, 

insbesondere über Formulare im Dokument, dabei greift JavaScript über das DOM (Document Object Model) auf 

die Elemente des HTML-Dokuments zu. Außerdem stehen drei Methoden des Window-Objektes bereit: alert(), 

confirm() und prompt(); mit jeder einzelnen dieser Methoden kann man den Benutzer auffällig ansprechen bzw. zu 

einer Eingabe auffordern. Dafür zeigt eine solche Methode ein modales Fenster an; modal bedeutet, der Benutzer 

muss dieses Fenster zunächst schließen, bevor er zum aufrufenden Dokument zurückkehren kann. 

Alarmfenster: 

Zeigt einen Text in einem eigenen Meldungsfenster an. Beispiel: 

window.alert("Hello World"); 

Bestätigungsfrage: 

Zeigt einen Dialog mit den Schaltflächen „OK“ und „Abbrechen“ an. Zurückgegeben wird einer der booleschen 

Werte true oder false, je nachdem welche Schaltfläche der Benutzer auswählt. 

var bestaetigt = window.confirm("Bitte bestätigen"); 

Eingabeaufforderung: 

Es wird ein Dialog zur Texteingabe angezeigt. Beispiel: 

var eingabe = window.prompt("Bitte geben Sie einen Text ein:", ""); 

In einem fertigen Script sind diese Methoden eher selten anzutreffen, während der Script-Entwicklung hingegen 

werden sie gerne benutzt, um Fehler auszumachen, um mit geringem Aufwand einen Variablenwert zu prüfen oder 

um festzustellen, ob eine bestimmte Stelle im Script überhaupt erreicht wird. 

Fehlerbehandlung 

Die neueren Versionen von ECMAScript, wie sie im Internet Explorer 5 und Netscape Navigator 6 eingebaut sind, 

verfügen über eine von Java übernommene Anweisung try … catch zur Fehlerbehandlung. 

Die Anweisung try … catch … finally fängt Ausnahmen (exceptions), die aufgrund eines Fehlers oder einer 

throw-Anweisung auftreten, ab. Die Syntax ist wie folgt: 

try { 

// Anweisungen, in denen Ausnahmen auftreten oder ausgelöst 

werden können 

} catch (exception) { 

} finally { 

wird. 

} 

… 

// Anweisungsfolge, die im Ausnahmefall ausgeführt wird. 

// In diesem Teil kann die Fehlerbehandlung erfolgen. 

// Anweisungsfolge, die anschließend in jedem Fall ausgeführt 

throw("sample exception");

JavaScript 80 

Zu Beginn werden die Anweisungen im try-Block ausgeführt. Falls eine Ausnahme auftritt, wird der Kontrollfluss 

sofort zum catch-Block mit dem Ausnahmeobjekt als Parameter umgeleitet. 

Im Normalfall wird der Ausnahmeblock übersprungen. Nach der Ausführung des try-Blocks (auch teilweise) und 

gegebenenfalls des catch-Blocks werden in jedem Fall die Anweisungen im finally-Block ausgeführt. Der 

finally-Teil kann weggelassen werden, alternativ der catch-Teil. 

JavaScript-Bibliotheken 

Für die Erstellung von browserübergreifenden Webanwendungen mit Hilfe von JavaScript stehen 

JavaScript-Bibliotheken, sogenannte Toolkits bereit. Es handelt sich dabei um eine Sammlung von 

JavaScript-Funktionen, die den JavaScript-Programmierer in seiner Arbeit unterstützen sollen. Toolkits, die nicht nur 

häufig benutzte Standardfunktionen zur Verfügung stellen, sondern durch ein besonderes Maß an Abstraktion eine 

grundlegend andere Programmierung nach sich ziehen, werden auch Frameworks genannt. 

Ausgelöst von neuen Konzepten wie Ajax entstand seit 2004 ein neues Interesse für JavaScript. JavaScript wird 

zunehmend für Rich-Client-Anwendungen benutzt, die das Aussehen und die Bedienung von herkömmlichen 

Desktop-Programmen auf Web-gestützte Anwendungen übertragen. JavaScript spielt dabei eine Schlüsselrolle. Im 

Zuge dieser neuen Anforderungen entstanden verschiedene Bibliotheken, die die Entwicklung solcher Anwendungen 

vereinfachen wollen. Neben Ajax-Funktionalitäten bieten die meisten dieser Bibliotheken eine eigene Basis für 

objektorientierte Programmierung, eine Abstraktionsschicht für das komfortable Arbeiten mit dem DOM sowie 

grafische Effekte wie Animationen. Aber auch schon vor dem breiten Einsatz von Ajax existierten 

Funktionssammlungen zur Unterstützung der browserübergreifenden Programmierung. 

Zu den bekannten JavaScript-Bibliotheken und Frameworks zählen Dojo Toolkit, Ext JS, jQuery, MooTools, 

Prototype, Qooxdoo und die Yahoo! UI Library. Speziell mit grafischen Effekten beschäftigen sich Moo.fx und 

Script.aculo.us. 

Einige JavaScript-Projekte implementieren eigene oder bereits existente andere Sprachen, um die 

Ausdrucksmöglichkeiten von Javascript zu erweitern, in anderen Sprachen geschriebene Skripte im Browser 

ausführen zu können, oder einfach zur Unterhaltung oder als Demonstration. Auch für JavaScript selbst existiert ein 

in JS geschriebener Interpreter, Narcissus. 

Mit CommonJS existiert ein Projekt, dass sich dem Ziel widmet eine Standardbibliothek für 

Anwendungsentwicklung mit Javascript zu spezifizieren. [8] Es gibt bereits eine erste Version der Spezifikation und 

mehrere Implementierungen [9] . 

Literatur 

• Mark Lubkowitz: Webseiten programmieren und gestalten – HTML, CSS, JavaScript, PHP, Perl, MySQL, SVG. 

2. Auflage, Galileo Press, Bonn 2005, ISBN 3-89842-557-6 

• Ralph Steyer: JavaScript. Einstieg für Anspruchsvolle. Addison-Wesley, München 2006, ISBN 3-8273-2466-1 

• David Flanagan: JavaScript – das umfassende Referenzwerk. 3. Auflage. O’Reilly, Köln 2007, ISBN 

3-89721-491-1 

• Michael Seeboerger-Weichselbaum: Das Einsteigerseminar JavaScript. 4. Auflage. bhv, Bonn 2007, ISBN 

3-8266-7472-3 

• Ralph Steyer: Das JavaScript Codebook. Addison-Wesley, München 2008, ISBN 3-8273-2717-2 

• Douglas Crockford: Das Beste an JavaScript. O’Reilly, Köln 2008, ISBN 3-8972-1876-3 

• Christian Wenz: JavaScript und AJAX. Das umfassende Handbuch. 9. Auflage. Galileo Press, Bonn 2009, ISBN 

3-89842-859-1 

• Stefan Koch: JavaScript – Einführung, Programmierung, Referenz. 5. Auflage. dpunkt.verlag, Heidelberg 2009, 

ISBN 3-89864-395-6

JavaScript 81 

Siehe auch 

• ActionScript – Bezeichnung für eine JavaScript-ähnliche Skriptsprache in Flash und Macromedia Director, wo es 

alternativ zu Lingo verwendet werden kann 

• Aktive Inhalte 

• Bookmarklet – kleine JavaScript-Programme im Browser 

• JavaScript Object Notation (JSON) 

Weblinks 

• Links zum Thema JavaScript [10] im Open Directory Project 

• JavaScript - Geschichte, Struktur, Eigenschaften und die Zukunft der wichtigsten Programmiersprache des Webs. 

[11] In: Chaosradio Express. 13. Februar 2010, abgerufen am 27. Februar 2010 (MP3, 97,5 MB). 

Spezifikationen 

• ISO-genormte ECMAScript-Spezifikation (ISO/IEC 16262:2002) [12] (Englisch/Französisch) 

• ECMAScript-Spezifikation [6] (Englisch, PDF) (HTML-Version [13] ) 

• Netscape JavaScript 1.3: Spezifikation von Mozilla [14] (Englisch) 

• JavaScript 1.5: Spezifikation/Referenz von Mozilla [15] (Englisch) 

• Übersicht über die Neuerungen in JavaScript 1.6 von Mozilla [16] (Englisch) 



Dokumentationen 

• JavaScript-Kapitel bei SELFHTML [19] 

• JavaScript und AJAX [20] (Online-Fassung von Christian Wenz: JavaScript und AJAX. Das umfassende 

Handbuch. Galileo Press, Bonn 2006, ISBN 3-89842-859-1) 

• Eloquent JavaScript [21] (Freiverfügbares E-Book) 

Referenzen 

[1] Brendan Eich: JavaScript at Ten Years (http:/ / www. mozilla. org/ js/ language/ ICFP-Keynote. ppt), 2005. 

[2] Sun Trademarks (http:/ / www. sun. com/ suntrademarks/ ) 

[3] Pressemitteilung von Sun zum Erscheinen der JRE 6.0 (http:/ / de. sun. com/ company/ press-releases/ 2006/ pm_20061211. html), 11. 

Dezember 2006. 

[4] John Resig. Versions of JavaScript (http:/ / ejohn. org/ blog/ versions-of-javascript). Ejohn.org. Abgerufen am 19. Mai 2009. 

[5] MDC: ECMAScript DontEnum attribute (https:/ / developer. mozilla. org/ En/ ECMAScript_DontEnum_attribute) 

[6] MDC: for each...in (https:/ / developer. mozilla. org/ en/ docs/ Core_JavaScript_1. 5_Reference:Statements:for_each. . . in) 

[7] siehe auch: named function expressions demystified (http:/ / yura. thinkweb2. com/ named-function-expressions/ ) 

[8] http:/ / www. commonjs. org 

[9] http:/ / wiki. commonjs. org/ wiki/ CommonJS#Implementations 

[10] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Internet/ JavaScript/ 

[11] http:/ / chaosradio. ccc. de/ cre146. html 

[12] http:/ / standards. iso. org/ ittf/ PubliclyAvailableStandards/ c033835_ISO_IEC_16262_2002(E). zip 

[13] http:/ / bclary. com/ 2004/ 11/ 07/ ecma-262. html 

[14] http:/ / devedge-temp. mozilla. org/ library/ manuals/ 2000/ javascript/ 1. 3/ reference/ 

[15] https:/ / developer. mozilla. org/ en/ docs/ Core_JavaScript_1. 5_Reference 

[16] https:/ / developer. mozilla. org/ en/ docs/ New_in_JavaScript_1. 6 



[19] http:/ / de. selfhtml. org/ javascript/ 

[20] http:/ / www. galileocomputing. de/ openbook/ javascript_ajax/

JavaScript 82 

[21] http:/ / eloquentjavascript. net/ 

Lua 

Lua (portugiesisch für Mond) ist eine imperative und erweiterbare Skriptsprache zum Einbinden in Programme, um 

diese leichter weiterentwickeln und warten zu können. Eine der besonderen Eigenschaften von Lua ist die geringe 

Größe des kompilierten Skript-Interpreters. 

Lua wurde 1993 von der Computer Graphics Technology Group der Päpstlichen Katholischen Universität von Rio 

de Janeiro in Brasilien entwickelt. Lua ist freie Software, und wurde bis zur Version 4 unter einer eigenen 

BSD-Lizenz, ab Version 5 unter der MIT-Lizenz veröffentlicht. 

Lua-Programme sind meist plattformunabhängig und werden vor der Ausführung in Bytecode übersetzt. Obwohl 

man mit Lua auch eigenständige Programme schreiben kann, ist sie vorrangig als Skriptsprache für andere 

Programme, wie z. B. für C-Programme, konzipiert. In dieser Hinsicht ist sie mit Tcl vergleichbar. Insbesondere die 

geringe Größe von 120 KB, die Erweiterbarkeit und die hohe Geschwindigkeit verglichen mit anderen 

Skriptsprachen überzeugen viele Entwickler davon, Lua einzusetzen. 

Der Lua-Interpreter kann über eine C-Bibliothek angesprochen werden, die auch ein API für die Laufzeitumgebung 

des Interpreters für Aufrufe vom C-Programm aus beinhaltet. Mittels des API können verschiedene Teile des 

Programmes in C und Lua geschrieben werden, während Variablen und Funktionen in beiden Richtungen erreichbar 

bleiben (d. h. eine Funktion in Lua kann eine Funktion in C aufrufen, und umgekehrt). 

Es gibt auch einen freien JIT-Compiler für die neueste Version (5.1) von Lua namens LuaJIT. 

Lua ist in ANSI-C implementiert und unterstützt imperative und funktionale Programmierung. Implementiert [1] man 

jedoch selbst Objekte mittels Metatables, wird auch objektorientierte Programmierung ermöglicht. 

Beispielprogramme in Lua 

Hallo Welt: 

print "Hello World" 

Beispiel für eine Rekursion: 

function factorial(n) 

end 

if n == 0 then 

else 

end 

return 1 

return n * factorial(n - 1) 

Befehle in Lua können – müssen aber nicht – am Ende einer Zeile mit einem Semikolon abgeschlossen werden. 

Die Syntax lehnt sich an die von Pascal an, was besonders Anfängern den Einstieg in Lua erleichtert. Im Gegensatz 

zu von Pascal abgeleiteten Sprachen nutzt Lua jedoch „==“ und nicht „=“ als Vergleichsoperator.

Lua 83 

Verwendung 

Lua kann sowohl zur Erstellung eigenständiger Programme verwendet werden als auch als eingebettete Sprache 

dienen. 

Es erfreut sich besonderer Beliebtheit bei Computerspielprogrammierern: Um einzelne Komponenten eines 

Computerspiels, wie z. B. Konfigurationsdateien oder die KI von computergesteuerten Charaktern oder Gegnern, 

von der Spiel-Engine zu trennen, kommt Lua in dieser Branche oft zum Einsatz. Dies macht die meist teuer 

entwickelte Spiel-Engine flexibler und ermöglicht eine mit geringerem Aufwand verbundene Wiederverwendbarkeit. 

Daher wird Lua im Bereich proprietärer Spiele verwendet, beispielsweise in: 

• Far Cry, Far Cry 2, Crysis, Crysis Warhead, 

• World of Warcraft, 

• Empire: Total War, 

• Dawn of War 

• Freelancer 

• Garrys Mod 

• Blitzkrieg 

Anwendung findet Lua ebenfalls in Desktopanwendungen, wie etwa Adobe Photoshop Lightroom [2] oder Anime 

Studio. Auch das freie Textsatzprogramm TeX integriert im neuen Ableger LuaTeX Lua als Skriptsprache. Der 

Boot-Manager GRUB2 bietet Lua als Ergänzung zu dessen Shell-ähnlicher Skriptsprache. Die 

Apache-Application-Firewall unterstützt mit dem Modul Mod Security ebenfalls Lua. Wireshark Packet Sniffer 

erlaubt dissector plugins in Lua zu schreiben. Die Firmware-Erweiterung CHDK erlaubt den Einsatz von 

Lua-Skripten auf Canon Digitalkameras. Außerdem findet Lua Verwendung als Konfigurationssprache für die 

Windowmanager Awesome und Ion. 

Literatur 

• Roberto Ierusalimschy: Programmieren mit Lua, September 2006, ISBN 3-937514-22-8 

• Roberto Ierusalimschy: Lua 5.1 Reference Manual, August 2006, ISBN 85-903798-3-3 

• Kurt Jung, Aaron Brown: Beginning Lua Programming, 2007, ISBN 0-470-06917-1 

• Paul Schuytema, Mark Manyen: Game Development with Lua, 2005, ISBN 1-58450-404-8 

Weblinks 

• http:/ / www. lua. org - Offizielle Homepage (auf Englisch und Portugiesisch) 

• Links zum Thema Lua [3] im Open Directory Project 

Referenzen 

[1] Ein Beispiel für die Definition einer Klasse und die Ableitung von Objekten daraus ist inequality-1.4.0 (http:/ / luaforge. net/ frs/ 

?group_id=49& release_id=767) (Anwendung: Berechnung von Ungleichverteilungsmaßen für die Wirtschafts- und Sozialwissenschaften). 

Das Programm ist sowohl in Lua wie auch in Python implementiert und ermöglicht dadurch einen Vergleich. 

[2] Einsatz von Lua in Lightroom: (http:/ / www. sauria. com/ blog/ 2008/ 10/ 09/ lua-in-lightroom/ ) 

[3] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ Lua/

Objective-C 84 

Objective- C 

Objective-C, auch kurz ObjC genannt, erweitert die Programmiersprache C um Sprachmittel zur objektorientierten 

Programmierung. Objective-C++ erlaubt teilweise die Mischung von Objective-C mit C++-Code mit dem Ziel, 

älteren Code verwenden zu können. Objective-C ist die primäre Sprache von Cocoa (Mac OS X) und GNUstep. 

Die Syntax und Konzeption der objektorientierten Erweiterungen ist an Smalltalk angelehnt und von der 

gewöhnlichen prozeduralen C-Syntax strikt getrennt. Diese Trennung erlaubt es, das gleiche Konzept zur 

Erweiterung auf andere imperative Sprachen anzuwenden; so gibt es z. B. ebenfalls Objective Pascal und 

Objective-J. 

Geschichte 

Objective-C wurde hauptsächlich von Brad Cox und Tom Love in den 80er Jahren bei PPI, später Stepstone, 

entwickelt, später dann von NeXT in die GNU Compiler Collection integriert, um als Basis für NextStep zu dienen. 

Wesentliche Eigenschaften 

Einer der Design-Gedanken von Objective-C war es, die Flexibilität von Smalltalk anzunähern, jedoch auf das zu 

verzichten, was das Laufzeitverhalten verschlechtern könnte. Der offensichtlichste Verzicht gegenüber Smalltalk ist 

das Fehlen von Blöcken. Daher ist ein Objective-C-Programm bereits zur Übersetzungszeit vollständig compilierbar. 

Viele Konzepte sind gar nicht in der Sprachdefinition selbst festgelegt, sondern werden erst durch das Framework, 

also etwa Cocoa oder GNUStep ermöglicht. Insbesondere ist das gesamte Laufzeitsystem nicht im Compiler 

implementiert, sondern besteht aus C-Funktionen. Bei Aufruf einer Member-Funktion in C++ etwa, fügt 

grundsätzlich der Compiler den entsprechenden Code ein, während in Objective-C (bei Versenden einer Nachricht 

an ein Objekt, dazu später mehr) die C-Funktion objc_msg_send() aufgerufen wird. Daher ist eine Darstellung ohne 

das entsprechende Laufzeitsystem kaum denkbar und nicht sinnvoll. Originäre Objective-C-Schlüsselwörter erkennt 

man indessen an dem vorangestellten @. 

Spätes Binden 

Die wohl gerade gegenüber C++-Programmen bemerkenswerteste Eigenschaft ist das späte Binden von Methoden. 

Polymorphie ist im Gegensatz zu Sprachen, die auf Simula-67 basieren, nicht nur innerhalb einer Klassenhierarchie 

möglich, sondern auch darüber hinaus. Eine Methode mit einem bestimmten Namen (Selector) kann von Objekten 

jeder Klasse ausgeführt werden, die sie implementieren. Es ist nicht erforderlich, dass der Aufrufer die Klasse kennt 

oder die Methoden bereits in einer Basisklasse – wenn auch nur virtuell – definiert worden sind. 

@interface KlasseA : NSObject { 

} 

// Instanzvariablen 

… 

- (void) doSomething; // Eine neue Methode in der Subklasse 

- (void) dumpToLog; // Noch eine 

@end 

@interface KlasseB : NSObject { 

} 

// Instanzvariablen 

…


- (void) dumpToLog; // Es wird nur die zweite Methode implementiert. 

@end 

id anObject = … // irgendeine Instanz der Klasse A oder B. 

[anObject dumpToLog]; 

// Obwohl beide Implementierungen unabhängig sind und 

// keine entsprechende Methode in der Basisklasse NSObject 

// existiert, wird die Methode jeweils sicher gefunden. 

Nachrichten, die an super (Hier: NSObject) geschickt werden, unterliegen allerdings nicht dem Dispatching, so dass 

sie bereits zur Übersetzungszeit vom Compiler der Superklasse zugeordnet werden: 

- (id)init { 

} 

self = [super init]; // Ruft stets die Methode der Superklasse auf 

… 

Dynamische Typisierung und typloses id 

Es ist daher für den Absender nicht notwendig, die Klasse des Empfängers zu kennen. Vielmehr existiert wie im 

obigen Code erkennbar ein Typ id, der für jedes Objekt jeder Klasse stehen kann. Dabei sei aber erwähnt, dass zwar 

der Zeiger auf ein Instanzobjekt nicht typisiert ist, um spätes Binden zu ermöglichen. Die einzelnen Instanzen sind 

stets typisiert, gehören also genau einer Klasse an. Objective-C typisiert also streng, jedoch dynamisch. 

Nachrichten 

Dies bedingt in Objective-C die strikte Trennung von Nachrichten und Methoden. Man spricht daher eigentlich in 

Objective-C gar nicht von Methodenaufrufen. Vielmehr gibt es einen Nachrichtensender (Sender) und einen 

Nachrichtenempfänger (Receiver). Alleine der Receiver entscheidet anhand der Nachricht, welche Methode 

ausgeführt wird. Dabei wird zunächst versucht, eine gleichnamige Methode zu finden. Es existiert dazu 

korrespondierend ein Datentyp SEL (Selector), der einen Nachrichtennamen abbildet. Zur vollständigen Nachricht 

fehlen dann noch die Parameter und der Empfänger. 

SEL nachricht = @selector( dumpToLog ); 

id anObject = … 

[anObject performSelector: nachricht]; 

Es ist darüber hinaus möglich, Nachrichtennamen erst zur Laufzeit zu erstellen. 

// Ein Text, der den Namen einer 1:n-Beziehung enthält. 

NSString *relationship = @"Children"; 

// Mittels String-Verarbeitung bauen wir uns zur Laufzeit daraus einen 

Nachrichtentext 

NSString *messageText = [NSString stringWithFormat: @"countOf%@", 

relationship]; 

// Das wird jetzt in eine Nachricht umgewandelt 

SEL message = NSSelectorFromString( messageText );


// Der Empfänger führt die entsprechende Methode aus: 

int countOfInstancesInRelationship = [receiver performSelector: 

message]; 

Kompliziertere Nachrichten, insbesondere mit zahlreichen Argumenten, werden als Instanzen der Klasse 

NSInvocation abgebildet. 

Hieraus ergibt sich die Möglichkeit, in einer IDE ganze Objektgraphen und Bedienungsoberflächen zu gestalten und 

zu verbinden, ohne dass die Eingabe von Sourcecode durch den Programmierer oder durch die IDE selbst 

erforderlich ist. Umgekehrt handelt es sich aber um das „normale“ Vorgehen des Dispatchers, sodass kein Aufsatz 

hierfür erforderlich ist und der Programmierer jederzeit die Kontrolle über die Ausführung jeder Methode behält 

(Beispielvideo von Apple) [1] . In der Realität entfällt damit ein Großteil der Programmierarbeit. 

Kategorien 

Kategorien sind Erweiterungen bereits bestehender Klassen um weitere Methoden. Hervorzuheben ist hierbei, dass 

die in den Kategorien enthaltenen Methoden auch Instanzen erweitern, die von fremden Code erzeugt werden. Dies 

gilt auch dann, wenn der fremde Code die Kategorie gar nicht kennt. 

Wir haben etwa eine Klasse NSNumber, die Zahlen darstellt. Dieser Klasse wollen wir eine Methode hinzufügen, die 

eine neue Instanz nach Addition einer anderen Instanz von NSNumber liefert. Also schreiben wir hierzu eine 

Kategorie: 

@interface NSNumber( CalculationAddition ) 

- (NSNumber*)numberByAddingNumber:(NSNumber*)summand; 

… 

@end 

@implementation( CalculationAddition ) 

- (NSNumber*)numberByAddingNumber:(NSNumber*)summand 

{ 

} 

// Additionskram 

… 

@end 

return sum; 

Die in dieser Kategorie enthaltenen Methoden können verwendet werden, wenn die Kategorie im Sourcecode 

bekannt ist in dem die Instanz erzeugt wird. Allerdings fällt hierbei bereits das Fehlen der Subklasse auf: 

# import "NSNumberCalculationAddition.h" 

… 

// Wir erzeugen eine Instanz der Basisklasse NSNumber! 

NSNumber* summand1 = [NSNumber numberWithInt:98]; 

NSNumber* summand2 = [NSNumber numberWithInt:11]; 

NSNumber* summe = [summand1 numberByAddingNumber:summand2]; 

Dies liegt darin begründet, dass bereits die Basisklasse selbst um die neuen Methode erweitert wird, Ableitung also 

nicht notwendig ist. 

Darüber hinaus verhält es sich jedoch so, dass diese Kategorie auch Instanzen hinzugefügt wird, die aus 

bestehendem Code stammen und daher unsere nachträglich hinzugefügte Kategorie gar nicht kennt! Wird also etwa 

in einem Framework, welches vor Jahren entwickelt wurde und dessen Sourcecode uns gar nicht vorliegt, eine


Instanz von NSNumber erzeugt, so hat diese ebenfalls die vorgenannte Methode. Damit ist es möglich, vollständig 

fremden Klassen Methoden hinzuzufügen. 

Protokolle 

Ähnlich wie in Java mit Interfaces lassen sich in Objective-C Sätze von Methoden in Protokollen zusammenfassen: 

@protocol MyDelegateProtocol 

// Instanzen der Klasse FileSystemGuard verschicken diese Nachricht 

an Delegates 

- (void) fileSystemGuard: (FileSystemGuard *) guard detectedMount: 

(NSString *) mountPath; 

@end 

RTTI/Reflexion 

Zur Laufzeit wird zu jedem Objekt ein Verweis auf seinen Typen, also die Klasse mitgeführt. Die Klasse enthält 

darüber hinaus eine Beschreibung aller Instanzvariablen und implementierten Methoden. Hieran entscheidet der 

Dispatcher im Receiver, welche Methode er der Nachricht zuordnet. Umgekehrt kann der Absender erfragen, welche 

Methoden implementiert sind. 

// Eine Methode, welche Nachrichten des GUI implementiert 

- (IBAction) doSomething: (id) sender { 

} 

// Klassenabfrage: RTTI 

if ([sender isKindOfClass: [NSButton class]]) { 

} 

// Es handelte sich um eine Instanz der Klasse NSButton 

[self doSomethingElseWithInt: [sender tag]]; 

// Methodenabfrage: Reflexion 

if ([sender respondsToSelector: @selector( tag )]) { 

} 

… 

- (void) setDelegate: (id) delegate { 

// Nur Delegates akzeptieren, die ein Mindestmaß an Methoden 

implementieren. Der Methodensatz ist 

)]) { 

} 

// im Protokoll MyDelegateProtocol angegeben. 

if (![delegate conformsToProtocol: @protocol( MyDelegateProtocol 

} 

…


Klassenobjekte 

In Objective-C existieren nicht nur Instanzobjekte (kurz: Instanzen), sondern auch Klassenobjekte. Die Bezeichnung 

„Exemplar einer Klasse“ ist daher in Objective-C mehrdeutig. Klassenobjekte können jedoch keine 

Member-Variablen enthalten und sind stets Singletons. Klassenmethoden werden durch ein vorangestelltes + 

gekennzeichnet. Da es sich um Objekte handelt, können diese zugewiesen werden. Sie haben selbst den Typen Class. 

Es existiert eine Instanzmethode -class und eine Klassenmethode +class, um das Klassenobjekt zu erhalten. 

// Eine Variable, die eine Klasse speichert 

Class aShapeClass; 

… 

// Es können Klassenobjekte zugewiesen werden: 

- (void) setShapeClass: (Class) newShapeClass { 

} 

aShapeClass = newShapeClass; 

- (void) addNewShape { 

id shape = [[aShapeClass alloc] init]; // Erzeugung einer Instanz 

der Klasse Shape 

} 

[shape markForRedraw]; 

[arrayWithAllShapes addObject: shape]; 

… 

Bemerkenswert ist in diesem Zusammenhang die Eigenschaft, dass es für diese Klassenobjekte einen self-Zeiger 

gibt, der der Polymorphie zugänglich ist: 

@interface Shape : NSObject { 

} 

+ (NSRect) boundingRectForShapeRect: (NSRect) shapeRect 

@end 

@interface Circle : Shape { 

} 

@end 

@implementation Circle; 

// Überschreiben einer Klassenmethode der Basisklasse 

+ (NSRect) boundingRectForShapeRect: (NSRect) shapeRect { 

} 

// Subklassenmethode 

// Es existiert ein self-Zeiger, der auf Circle oder eine Subklasse 

von Circle zeigt. 

@end 

[self doSomething]; 

…


… 

NSRect boundingRect; 

// Nicht polymorpher Aufruf: Entspricht in etwa 

Shape::boundingRectForShapeRect() in C++ 

boundingRect = [Shape boundingRectForShapeRect: aRect]; 

Shape *aShape = … // Eine Instanz der Klasse Shape oder einer Subklasse 

wie Circle 

// Polymorpher Aufruf einer Klassenmethode 

[[aShape class] boundingRectForShapeRect: aRect]: 

… 

Syntax 

Die Syntax von Objective-C erweitert die C-Syntax um objektorientierte Elemente. Diese Syntaxerweiterungen 

lehnen sich jedoch nicht an die C-Syntax an, wie es etwa viele verbreitete objektorientierte Programmiersprachen 

tun, sondern an die der Programmiersprache Smalltalk. Der Hintergrund ist, dass der objektorientierte Aufsatz sich 

grundsätzlich auch mit anderen Programmiersprachen kombinieren lässt, etwa mit Pascal zu Objective-Pascal. 

Sämtliche neuen Schlüsselwörter sind mit einem voranstehendem @ gekennzeichnet. 

Klassendefinition 

Um seine eigene Art von Objekten zu erstellen, muss man sie in einer Klasse beschreiben. Dazu werden im 

@interface-Teil – gewöhnlich in einer Header-Datei – die Klasse. Hier im Beispiel eine Bruch-Klasse. 

// Klassenbezeichnung und Ableitung 

@interface Bruch : NSObject < Protokoll > 

// Instanzvariablen, für jede Instanz angelegt. 

{ 

} 

NSInteger zaehler; 

NSInteger nenner; 

// Eigenschaften der Instanzen 

@property( assign ) NSInteger zaehler; 

@property( assign ) NSInteger nenner; 

// Methoden: 

- (void) printLn; 

- (float) floatValue; 

@end 

Im Einzelnen:


Klassenbezeichnung und Vererbung 

@interface Bruch : NSObject < Protokoll > 

Jede Klasse hat einen Namen, der konventionsgemäß mit einem Großbuchstaben beginnt und im Camel-Case 

(neueWoerterErhaltenWiederEinenGroßbuchstaben) fortgeführt wird. Die Bezeichner folgen den C-Regeln, dürfen 

also insbesondere keine Umlaute enthalten. Durch einen Doppelpunkt getrennt wird sodann die Basisklasse 

angegeben. Schließlich können in spitzen Klammern Protokolle angegeben werden, deren Implementierung 

versprochen wird. Handelt es sich um mehrere Protokolle, so sind deren Namen in den Klammern mit Kommata 

getrennt aufzulisten. 

Instanzvariablen 

Es folgt in geschweiften Klammern die Liste der Instanzvariablen. 

{ 

} 

NSInteger zaehler; 

NSInteger nenner; 

Diese werden für jede Instanz angelegt. Die Sichtbarkeit lässt sich über Abschnitte mit @public, @private, 

@protected und @package (nur bei 64-Bit-Laufzeitsystem) steuern. @public bedeutet hierbei, dass jeder auf diese 

Instanzvariable zugreifen darf, @protected, dass dies nur im Code derselben Klasse oder abgeleiteten Klassen 

erfolgen darf, @private dass dies nur in derselben Klasse erfolgen darf und @package, dass dies nur in Klassen des 

Frameworks erfolgen darf. Standard ist @protected, welches wegen anderer Technologien tatsächlich fast immer 

verwendet wird. Daher enthalten die allermeisten Klassendefinitionen keines der Schlüsselwörter zur Sichtbarkeit. 

Properties (Eigenschaften) 

Nach den Instanzvariablen ist es seit Objective-C 2 möglich, Eigenschaften (Attribute oder Beziehungen) 

aufzulisten. Die Definition einer Property hat die Form 

@property( Attributliste ) Typ name; 

Die Attribute lassen sich hinsichtlich des Schreibschutzes, des Referenzmodelles und der Atomarität unterscheiden. 

• Für den Schreibschutz existieren die Attribute readonly und readwrite (Default) 

• Atomarität: mit nonatomic lässt sich zusätzlich erreichen, dass bei Übersetzung im Speichermodell 

Reference-Counting zusätzliche retain- und autorelease-Nachrichten an eine zurückgegebene Instanz gesendet 


• Die Referenzierung wird über die Wörter assign (Default) als reine Zuweisung im Setter auch dann, wenn der Typ 

der Property ein Instanzzeiger ist, retain als Referenz im Sinne des Reference-Countings (der Parameter erhält die 

Nachricht retain) und copy, wenn der Setter eine Kopie anfertigen soll (der Parameter erhält die Nachricht copy), 

beschreiben. 

Werden nur Default-Eigenschaften verwendet, so kann die Attributliste samt Klammer weggelassen werden: 

@property NSInteger zaehler; 

Wird jedoch der Code mit Referenz-Counting als Speichermodell übersetzt und soll eine Eigenschaft mittels assign 

nur zugewiesen werden, so muss dies obwohl Default-Einstellung, explizit angegeben werden. Ansonsten erteilt der 

Compiler eine Warnung. Es bietet sich generell an, bei Instanzenzeigern explizit das Referenzmodell anzugeben, 

während es bei C-Typen überflüssig ist, da nur assign sinnvoll ist.


@property NSInteger zaehler; // NSInteger ist ein C-Typ 

@property( copy ) NSString* name; // NSString* ist ein Instanzzeiger. 

Methodendeklarationen 

Als nächstes folgt eine Liste von Methoden: 

- (void) printLn; 

- (float) floatValue; 

Jede einzelne Methodendeklaration beginnt zunächst mit einem + (Klassenmethode) oder - (Instanzmethode). 

Hiernach folgt in Klammern der Typ des Rückgabewertes, wobei wie in C void als Schlüsselwort für keinen 

Rückgabewert steht. Anschließend folgt der Methodenname, wobei wieder die Regeln für C-Bezeichner gelten. Soll 

die Methode einen Parameter enthalten, so folgt als Teil des Bezeichners die äußere Beschreibung des ersten 

Parameters, ein Doppelpunkt, in Klammern der Typ und sodann ein Bezeichner. Folgen noch Parameter, so werden 

diese nach einem Leerzeichen wieder mit einem beschreibenden Namen versehen (der auch 0 Zeichen haben kann), 

einem Doppelpunkt, in Klammern der Typ und sodann ein Bezeichner: 

- (id)initWIthZaehler:(NSInteger)zaehler andNenner:(NSInteger)nenner; 

Abgeschlossen wird die Deklaration mit einem Semikolon. 

Die Klassendefinition wid mit @end abgeschlossen. 

Implementierung 

Die Implementierung erfolgt in einer weiteren Datei, die Standardmäßig auf .m endet (Eselsbrücke: iMplementation 

oder Module). Sie endet mit einem @end. Dazwischen erfolgt die Implementierung der Methoden – gleichgültig, ob 

im Interface bekannt gemacht oder nicht. Dabei sind Standardmethoden und synthetisierte Methoden (nur 

Objective-C 2) für Eigenschaften (siehe oben) zu unterscheiden, Einfache Methoden entsprechen in ihrem Kopf der 

Methodendeklaration. Jedoch tritt an die Stelle des Semikolons (der jedoch optional bleibt, unüblich!) die 

Anweisungsliste in geschweiften Klammern: 

- (id)initWithZaehler:(NSInteger)zaehler andNenner:(NSInteger)nenner 

{ 

} 

// Code hier 

Es sei darauf hingewiesen, dass die Bezeichner der formalen Parameter nicht denen aus der Methodendeklaration 

entsprechen muss. Synthetisierte Methoden sind die Accessoren für die Eigenschaften: 

@synthesize zaehler, nenner; 

Es werden dann Methoden erzeugt, die die im Interface angegebenen Attribute befolgen. Standardmäßig verwendet 

der Compiler dabei gleichnamige Instanzvariablen. Dem Programmierer bleibt es aber vorbehalten, selbst diese 

Methoden auszuformulieren, wobei diese den Namen eigenschaft und setEigenschaft (nur bei readwrite) tragen 

müssen: 

- (NSInteger)zaehler { return zaehler; } 

- (void)setZaehler:(NSInteger)value { zaehler = value; ) 

Eine weitere Möglichkeit besteht darin, dass man eine Eigenschaft mittels @dynamic bezeichnet. In diesem Falle 

überprüft der Compiler nicht mehr das Vorhandensein in der Implementierung. Man kann also die entsprechenden 

Methoden zur Laufzeit simulieren oder selbst der Klasse hinzufügen: 

@dynamic zaehler; // Accessormethoden werden zur Laufzeit gehandhabt.


Nachrichten 

Da Objective-C zwischen Nachricht und Methode unterscheidet, wird für das Versenden von Nachrichten keine an 

den C-Funktionsaufruf angelehnte Syntax verwendet. Vielmehr erfolgt der Versand in der Form: 

[Objekt Nachricht] 

Soll eine Nachricht an ein Klassenobjekt verschickt werden, damit eine Klassenmethode ausgeführt wird, so schreibt 

man einfach die Klasse als Empfänger hin: 

Bruch* bruch = [Bruch alloc]; // +alloc ist Klassenmethode 

Bei Nachrichten an die Instanzmethode wird deren Zeiger verwendet: [bruch initWithZaehler:3 andNenner:4]; Wie 

ersichtlich, werden dabei die Parameter eingesetzt und mittels Leerzeichen, nicht Komma, getrennt. Nachrichten 

können auch verschachtelt werden. Z. B. 

NSString *string = @"Hallo Welt"; 

NSData *data = [NSData dataWithBytes:[string cString] length:[string 

cStringLength]]; 

Hiermit wird ein neues Objekt der Klasse NSData erstellt. Die Bytes, die in das neue Objekt kopiert werden, werden 

mit [string cString] erfragt, die Länge des Blocks mit [string cStringLength]. 

Es werden also die Rückgabewerte der Methoden verwendet. Dies geht auch beim Empfänger, zum Beispiel : 

Bruch* bruch = [[Bruch alloc] init] 

Das Objekt, das mit [Klasse alloc] erzeugt wurde, bekommt die Botschaft init. 

Locking 

Objective-C bietet eine Syntax für Locks bei Threading an. Hierzu wird ein Code-Abschnitt mit dem Schlüsselwort 

@synchronized eingeleitet, welches als Parameter ein Objekt als Lock erhält: 

@synchronized( anInstance ) { 

} 

// Exklusiver Code für den Lock anInstance 

Exceptions 

Exceptionhandling erfolgt in Objective-C mittels @try, @catch, @finally und @throw; 

@try { 

} 

// Code, der eine Exception auslösen könnte 

@catch( NSException* exception ) { // Klasse von Exceptions, die 

gefangen werden sollen 

} 

// Code, wenn eine Exception auftrat 

@finally { 

} 

// Code, der in jedem Falle ausgeführt wird 

Geworfen wird eine Exception – unmittelbar mit Sprachmitteln – mittels des Schlüsselwortes @throw; Durch 

Angaben verschiedener Klassen kann man sowohl auf derselben Ebene wie auch in Hierachien bestimmt werden,


welcher Klasse eine Exception sein soll, die gefangen wird. Im @catch-Block kann die Exception erneut geworfen 

werden und wird dann von einem äußeren Exceptionhandler behandelt. 

Klassenobjekte 

Objective-C besitzt so genannte Klassenobjekte. Dies bedeutet: Nicht nur die Instanzen, sondern auch die Klassen 

sind Objekte und können Nachrichten empfangen, wie oben [Klasse alloc]. – Zum Instanzieren sind damit keine 

zusätzlichen Sprachelemente wie Konstruktoren und Schlüsselwörter nötig. 

In der Klassendefinition werden Klassenmethoden mit ‚+‘, Instanzmethoden mit ‚-‘ gekennzeichnet. 

+alloc ist kein Bestandteil der Sprachbeschreibung, sondern eine – beliebige – Methode des Frameworks und daher 

der eigenen Implementierung zugänglich. Die Methode zu überschreiben ist jedoch nur für Experten eine gute Idee. 

Ganz im Gegensatz ist die Methode +initialize, die vor Verwendung einer Klasse aufgerufen wird, standardmäßig 

leer und kann für klassenbezogene Vorauseinstellungen überschrieben werden. 

Typkonzept 

Objective-C fügt zu den Standard-C-Datentypen den Datentyp id hinzu. Ein Objekt des Types id ist irgendein 

Objekt. Was mit diesem Objekt angefangen werden kann, wird erst zur Laufzeit bestimmt. Hierzu existieren 

Methoden, etwas über das Objekt zu erfahren. Wichtig sind: 

• [obj class] // bestimmt die Klasse 

• [obj respondsToSelector:] // bestimmt, ob eine Methode vorhanden ist 

• [obj conformsToProtocol:] // bestimmt, ob ein Protokoll implementiert ist 

Das Typkonzept erlaubt zudem die Typisierung des allgemeinen Objektes oder anderer Objekte durch (formale) 

Protokolle. Diese legen einen Satz von Methoden fest. Auch diese Protokolle müssen nicht in einem Hierarchiebaum 

einheitlich sein, werden aber vererbt. 

Die Typfreiheit erlaubt die Erstellung allgemeiner Container, die anders als templates auch typgemischt (heterogen) 

sein können. 

NSMutableDictionary *meineWelt = [[NSMutableDictionary alloc] init]; 

// Eine Map mit einem String, einer URL und einem Wert 

[meineWelt setObject: @"Ein Text" forKey: @"Text"]; 

[meineWelt setObject: [NSURL URLWithString: @"www.example.com"] forKey: 

@"URL"]; 

[meineWelt setObject: [NSNumber numberWithInt: 3] forKey: @"Zahl"]; 

// Alle Objekte implementiern die Methode description 

NSLog( @"%@", [[meineWelt objectForKey: @"Text"] description] ); 

NSLog( @"%@", [[meineWelt objectForKey: @"URL"] description] ); 

NSLog( @"%@", [[meineWelt objectForKey: @"Zahl"] description] ); 

[meineWelt release]; 

Ausgabe: Ein Text www.example.com 3


Spätes Binden 

Objective-C bindet einen Methodenaufruf erst zur Laufzeit an eine Methode. Grundsätzlich ist dies auch in C++ so. 

Jedoch muss in C++ bereits zur Übersetzungszeit sichergestellt sein, dass eine Methode existiert, weil sie zu der 

Klassenhierarchie gehört. C++ ist also nur bereit, innerhalb eines Zweiges einer Hierarchie spät zu binden, während 

Objective-C dies unabhängig von der Stellung einer Klasse in einem Hierarchiebaum macht. Dies soll an einem 

Syntax-neutralen Beispiel verdeutlicht werden: 

Klasse A 

methode() 

Klasse B von Klasse A 


Klasse C 

... 


// Spätes Binden in C++ 

A* objekt = new B; 

objekt->methode(); // Ruft in Wahrheit B::methode auf 

delete objekt; 

objekt = new C; // Führt zu Fehlern, da typfremd. 

objekt->methode(); // Auch mit casting geht dies nicht, weil 


// Spätes Binden in oC 

// in einem anderen Zweig des Baumes auftaucht, 

// obwohl C::methode() sehr wohl existiert 

id objekt = [[B alloc] init]; // id bedeutet „Irgend ein Objekt“ 

[objekt methode]; // Funktioniert, weil B methode() kennt 

[objekt release]; 

objekt = [[C alloc] init]; 

[objekt methode]; // Funktioniert auch, weil C die methode() kennt 

// Wo sie in der Klassenhierarchie bekannt ist, 

// spielt keinerlei Rolle 

Zu diesem Zweck führt Objective-C zur Laufzeit umfangreiche Informationen über ein Objekt mit, was über RTTI 

hinausgeht. 

Aus dem letztlich gleichen Grunde ist es auch ohne weiteres möglich, zur Laufzeit erst eine Methode zu bestimmen. 

Die Methode kann sich ähnlich wie bei einem Methodenzeiger in einer Variablen befinden, die erst zur Laufzeit mit 

einem Wert besetzt wird: 

methode = @selector( eineMethode ); 

[objekt performSelector: methode]; // Ruft die Methode eineMethode auf 

methode = @selector( andereMethode ); 

[objekt performSelector: methode]; // Ruft andereMethode auf 

Von dieser Technik macht etwa Cocoa bei der Bindung von Interface-Elementen an Methoden regen Gebrauch. Die 

Bestimmung der Methode kann auch durch ihren Klarnamen erfolgen.



NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] init]; 

[aDictionary setObject: @"Ei" forKey: @"egg"]; 

[aDictionary setObject: @"Auto" forKey: @"car"]; 

[aDictionary setObject: @"Hallo Welt!" forKey: @"Hello, world!"]; 

NSLog([aDictionary objectForKey: @"Hello, world!"]); 

[aDictionary release]; 

Objective-C++ 

Objective-C++ ist ein Frontend der GNU Compiler Collection das Quellen übersetzen kann, die sowohl C++- als 

auch Objective-C-Syntax verwenden. Objective-C++ versucht nicht, die unterschiedlichen Konzepte der beiden 

Sprachen zu vereinheitlichen. Vielmehr erweitert es lediglich C++ um die Erweiterungen, die Objective-C zu C 

hinzufügt. Dies führt zu gewissen Einschränkungen: 

• C++-Klassen können nicht von Objective-C-Klassen erben. 

• Umgekehrt können Objective-C-Klassen auch nicht von C++-Klassen erben. 

• Innerhalb einer Objective-C-Deklaration kann man keine C++-Namensräume deklarieren. 

• C++-Klassen, die keinen Defaultkonstruktor haben, oder die virtuelle Funktionen haben, können nicht als 

Instanzvariablen einer Objective-C-Klasse verwendet werden. Wohl aber kann man Zeiger auf solche Klassen 

verwenden. 

• Objective-C-Objekte können nicht als Wertparameter verwendet werden, da sie nur über Zeiger ansprechbar sind. 

• Objective-C-Deklarationen können nicht in C++-Template-Deklarationen benutzt werden, und umgekehrt. Jedoch 

können Objetive-C-Typen (wie z. B. Klassenname *) als C++-Template-Parameter benutzt werden. 

• Die Ausnahmebehandlungsmechanismen von Objective-C und C++ sind voneinander unabhängig; Ein 

Objective-C-Exception-Handler kann keine C++-Exceptions auffangen und umgekehrt. Dies gilt allerdings nicht 

mehr für das 64-Bit-Runtime von Objective-C 2.0, da hier das Exceptionkonzept von C++ übernommen wurde. 

• Besondere Vorsicht erfordert die Tatsache, dass die Konventionen zum Aufruf von Destruktoren nicht kompatibel 

sind. So wird etwa ein C++-Destruktor nicht aufgerufen, wenn der Gültigkeitsbereich des C++-Objekts mittels 

einer Objective-C-Ausnahme verlassen wird. 

Ein typischer Anwendungsbereich von Objective-C++ ist zum Beispiel die Verwendung einer C++-Bibliothek in 

einer Objective-C-Anwendung. 

Objective-C 2.0 

Im Oktober 2007 hat Apple mit Mac OS X 10.5 Objective-C 2.0 ausgeliefert, eine Erweiterung von Objective-C, die 

„moderne Garbage Collection, Syntaxerweiterungen, Verbesserungen der Laufzeitleistung und 64-Bit-Unterstützung 

umfasst“. [2] 

Die GNU Laufzeitumgebung für Objective-C unterstützt diese Erweiterungen derzeit (Mai 2009, GCC 4.4) jedoch 

nur teilweise.


Garbage Collection 

Objective-C 2.0 enthält einen optionalen konservativen Garbage Collector. 

Properties 

Objective-C 2.0 führt eine neue Syntax ein, mit der man Instanzvariablen als Properties deklarieren kann. Die 

Syntax unterstützt optionale Attribute, welche die Zugriffsmethoden näher definieren: Eine Property kann als 

readonly deklariert werden, und kann mit verschiedenen Verhaltensregeln zur Speicherverwaltung wie „assign“, 

„copy“, „retain“ versehen werden. 

@interface Person : NSObject { 

} 

@public NSString *name; 

@private int age; 

@property(copy) NSString *name; 

@property(readonly) int age; 

-(id)initWithAge:(int)age; 

@end 

Properties werden mit dem Schlüsselwort @synthesize implementiert, welches Getter und Setter-Method gemäß der 

Property-Deklaration erzeugt. Alternativ kann man auch das Schlüsselwort @dynamic verwenden, um anzuzeigen, 

dass man diese Methoden selber implementiert. In diesem Falle ist es jedoch optional, da der Compiler die 

Implementierung der Accessoren bemerken kann und bemerkt. Wichtiger ist das Schlüsselwort @dynamic, wenn die 

Accessoren erst zur Laufzeit erzeugt werden. Denn hier würde der Compiler eine entsprechende Definition 

vermissen und eine Warning ausgeben. Dies ist etwa bei Managed Objects der Fall, die zur Laufzeit Accessoren aus 

der geladenen Beschreibungsstruktur der Entität erzeugen. 

@implementation Person 

@synthesize name; 

@dynamic age; 

-(id)initWithAge:(int)initAge 

{ 

age = initAge; // Dies ist ein direkter Zugriff auf die 

Instanzvariable, der Property-Setter wird hier nicht verwendet 

} 

return self; 

-(int)age 

{ 

} 

@end 

return 29; // Beispiel: lügt bezüglich des Alters


Dot-Notation 

Auf Accessoren, gleichgültig ob explizit definiert oder als Property angelegt, kann mit der aus anderen Sprachen 

bekannten Punkt-Notation zugegriffen werden. Hierbei erfolgt allerdings kein unkontrollierter Zugriff auf die 

Instanzvariable, sondern es werden die Accessoren -eigenschaft und -setEigenschaft: verwendet. 

Person *aPerson = [[Person alloc] initWithAge: 53]; 

aPerson.name = @"Steve"; // Punkt-Notation, verwendet den Setter 

NSLog(@"Zugriff per Getter (%@), Property-Name (%@) und Direktzugriff 

auf die Instanzvariable (%@)", 

aPerson.name, [aPerson valueForKey:@"name"], aPerson->name); 

Um die Punktnotation innerhalb einer Instanzmethode zu verwenden, benutzt man das Schlüsselwort self: 

-(void) introduceMyselfWithDotNotation 

{ 

NSLog(@"Hallo, mein Name ist %@.", self.name); // verwendet Getter 

NSLog(@"Hallo, mein Name ist %@.", name); // Direktzugriff auf die 

Instanzvariable 

} 

Auf die Eigenschaften einer Instanz kann auch dynamisch per Reflexion zugegriffen werden: 

int i, propertyCount = 0; 

objc_property_t *propertyList = class_copyPropertyList([aPerson class], 

&propertyCount); 

for (i=0; i


Folgen für die Cocoa-Entwicklung 

In Objective-C geschriebene Mac-OS-X-Anwendungen, die diese Objective-C-2.0-Verbesserungen benutzen, sind 

mit Versionen von Mac OS X vor 10.5 (Leopard) inkompatibel. 

Vergleich zu anderen Programmiersprachen 

C++ 

Obwohl beide Sprachen in C einen gemeinsamen Vorfahren haben, ergeben sich insbesondere aus dem späten 

Binden und der Möglichkeit, Klassen und Nachrichten zur Laufzeit zu erstellen, erhebliche Konzeptunterschiede. 

Funktionalitätsspezialisierung 

Ein häufiges Grundproblem der klassenbasierten Programmierung ist die Spezialisierung einer 

Standardfunktionalität. Das Mittel der Wahl ist in C++ meist die Ableitung. Hiergegen wird eingewendet, dass bei 

der Ableitung "Innereien" der Basisklasse bekannt werden (White-Boxing). Demgegenüber lässt sich in Objective-C 

leicht das Delegating implementieren, welches eine Funktionsspezialisierung durch Nachfrage bei einem Objekt 

einer anderen Klasse zulässt. Die zu spezialisierende Klasse bleibt also gekapselt (Black-Boxing). 

Dies sei an einem Beispiel verdeutlicht: Es sei ein Tableview (eine Darstellung einer Tabelle mit Zeilen und Spalten 

im UI), welches Selektion zulässt. Man nehme ferner an, dass bei der Selektion eine zentrale Methode -selectRow: 

aufgerufen wird. Diese ist berechtigt, die Selektion abzulehnen. 

Bei einer Lösung mittels Ableitung würde man die Methode -selectRow: in einer Subklasse MyTableView : 

NSTableView spezialisieren: 

- (BOOL)selectRow:(NSInteger)rowIndex 

{ 

} 

// Die erste Zeile gruppiert nur und darf nicht selektiert werden. 

if( rowIndex == 0 ) { 

return NO; 

} else { 

} 

return YES; 

Bei einem Delegate befragt indessen das Tableview sein Delegate. Dieses ist von irgendeiner Klasse: 

- (BOOL)tableview:(NSTableView*)tableView 

shouldSelectRow:(NSInteger)rowIndex 

{ 

} 

// Die erste Zeile gruppiert nur und darf nicht selektiert werden. 

if( rowIndex == 0 ) { 

return NO; 

} else { 

} 

return YES; 

Der gleiche Code wird also aus der Klasse ausgelagert. Ähnlich wie bei der Ableitung ist dabei die Implementierung 

einer Delegate-Methode in der Regel ein Angebot, keine Pflicht. In diesem Falle würde also das Tableview 

nachfragen, ob sein Delegate die Methode -tableView:shouldSelectRow: implementiert:


// Pseudocode NSTableView.m 

- (BOOL)selectRow:(NSInteger)rowIndex { 

} 

SEL method = @selector( tableView:shouldSelectRow: ); 

// Nur bei Implementierung 

if( [delegate respondsToSelector:method ) { 

return [delegate tableView:self shouldSelectRow:rowIndex]; 

// Standardverhalten 

} else { 

} 

return YES; 

Diese Fähigkeit von Objective-C wird in weiten Teilen von Cocoa ausgenutzt. 

Funktionalitätserweiterung 

Auch die Erweiterung einer bestehenden Klassenfunktionalität wird in C++ häufig über Subklassen implementiert. 

Objective-C bietet demgegenüber Kategorien als Lösungsmöglichkeit an. Hierbei wird nachträglich der 

Methodensatz einer Klasse erweitert. 

Literatur 

• Amin Negm-Awad und Christian Kienle: Xcode, Objective-C und Cocoa. 1. Auflage. 2009. in: Horst-Dieter 

Radke (Hrsg.): Automatisierung und Anwendungsentwicklung auf dem Mac – Einführungen. 1 Auflage. 

SmartBooks Publishing AG, 2009, ISBN 978-3-9084-9798-1. 

• Amin Negm-Awad: Objective-C und Cocoa Band 1: Grundlagen. 2./4. Auflage. SmartBooks Verlag, 2009, ISBN 

978-3-9084-9782-0. 

• Cocoa: Progammierung für Mac OS X, 3. Ausgabe, Aaron Hillegass, Mitp-Verlag, 2008, Deutsch, ISBN 

3-8266-5960-0 

• Programming in Objective-C, Stephen Kochan, Sams, 2003, Englisch, ISBN 0-672-32586-1 

• Object-Oriented Programming and the Objective C Language, NeXTSTEP Developers Library Release 3, 

Addison-Wesley, 1993, ISBN 0-201-63251-9, 240 Seiten 

• Object-Oriented Programming: an evolutionary approach, Brad J. Cox and Andrew J. Novobilski, 

Addison-Wesley, 1986, 1991 (2nd Edition), ISBN 0-201-54834-8, 270 Seiten. Einführung vom Autor dieser 

Sprache. 

Weblinks 

• Einstieg in Objective-C im Mac OS X Entwicklerforum Wiki [3] 

• Introduction to The Objective-C Programming Language (Apple Developer Connection) [4] 

• Object-Oriented Programming and The Objective-C Language [5] 

• Object Oriented Programming in Objective-C [6] 

• Objective-C FAQ [7] 

• Objective-C: Links, Resources, Stuff [8]


Tutorials 

• Objective-C, Xcode und Cocoa Tutorial [9] 

• Properties für Accessoren (Das Wichtigste für Umsteiger) [10] 

• Absolute Beginner – Einführung in Objective-C, Cocoa und Xcode [11] 

Referenzen 

[1] http:/ / developer. apple. com/ cocoa/ coredatatutorial/ 

[2] http:/ / developer. apple. com/ leopard/ overview/ objectivec2. html Apple - Objective-C 2.0 Overview 

[3] http:/ / wiki. osxentwicklerforum. de/ doku. php?id=wiki:einstieg_objective-c 

[4] http:/ / developer. apple. com/ documentation/ Cocoa/ Conceptual/ ObjectiveC/ 

[5] http:/ / www. toodarkpark. org/ computers/ objc/ 

[6] http:/ / www. cs. indiana. edu/ classes/ c304/ oop-intro. html 

[7] http:/ / www. faqs. org/ faqs/ computer-lang/ Objective-C/ faq/ 

[8] http:/ / www. foldr. org/ ~michaelw/ objective-c/ 

[9] http:/ / www. infobliss. at/ objc/ obc001_index. htm 

[10] http:/ / www. daubit-blog. org/ 2009/ 06/ propertys-for-accessors/ langswitch_lang/ de/ 

[11] http:/ / www. cocoading. de/ Common/ Article. php?Area=2& Article=3 

Pascal (Programmiersprache) 

Pascal 

Paradigmen: imperativ, strukturiert 


Entwickler: Niklaus Wirth 

Dialekte: UCSD-Pascal, Borland Turbo Pascal 

Einflüsse: ALGOL 

Beeinflusste: Modula-2, Ada, Delphi, Oxygene, WEB 

Die Programmiersprache Pascal (benannt nach Blaise Pascal) wurde von Niklaus Wirth an der ETH Zürich 1972 als 

Lehrsprache eingeführt, um die strukturierte Programmierung zu etablieren. 

Allgemeines zur Sprache 

Pascal ist eine Weiterentwicklung von Algol 60. 

Die Sprache wurde von Niklaus Wirth als Lehrsprache entwickelt. Sie wurde deshalb so einfach und strukturiert wie 

möglich gestaltet. Ihre große Verbreitung in der professionellen Programmierung fand sie als Borland/Turbo Pascal 

(Delphi) – gegenüber dem Ur-Pascal wesentlich erweiterte und verbesserte Versionen. 

Pascal zeichnet sich durch eine strikte und einfach verständliche Syntax sowie durch den Verzicht auf 

kontextabhängige Interpretationen des Codes aus. Somit erlaubt Pascal im Vergleich zu Sprachen wie C und Fortran 

eine gute Lesbarkeit und, verglichen mit Fortran, auch eine bessere Unterstützung von strukturierter 

Programmierung. 

Ein wichtiges Konzept, das Wirth zur Anwendung brachte, ist die starke Typisierung (engl. "strong typing"): 

Variablen sind bereits zur Übersetzungszeit einem bestimmten Datentyp zugeordnet, und dieser kann nicht 

nachträglich verändert werden. Typenstrenge bedeutet, dass Wertzuweisungen ausschließlich unter Variablen 

gleichen Typs erlaubt sind. In Pascal gibt es von diesem strikten Zwang lediglich wenige Ausnahmen: 

• Wertzuweisungen der Form [Variable vom Typ real] := [Wert vom Typ integer].


• In Extended-Pascal Wertzuweisungen von ganzzahligen oder reellen Zahlen an Variablen vom Type Complex. 

• Wertzuweisungen von eingeschränkten Wertebereichen eines ordinalen Typs. Beispiel: type int10 = 1 .. 10; Werte 

dieses Typs können dann Integervariablen zugewiesen werden. 

• Wertzuweisungen von Mengen eines eingeschränkten Wertebereichen eines ordinalen Typs. Beispiel: type set10 

= set of 1 .. 10; set20 = set of 1 .. 20; Werte des Typs set10 können dann Variablen des Typs set20 zugewiesen 


• Wertzuweisungen auf eingeschränkte Wertebereichen eines ordinalen Typs oder einer Menge. In diesem Fall 

rufen Werte bzw. Mengen-Elemente außerhalb des Zielbereichs einen Laufzeitfehler hervor. 

• Wertzuweisungen zwischen unterschiedlichen String-Typen, inkl. Char, Zeichen-Arrays gemäß Standard-Pascal 

und den verschiedenen String-Typen in Extended-Pascal, Borland Pascal usw. Sofern die Länge des Wertes nicht 

innerhalb der Kapazität des Ziels liegt, ergibt sich auch hier ein Laufzeitfehler. 

Heute findet Pascal im universitären Bereich (Entwicklung/Ausbildung) und in sicherheitskritischen Bereichen (z. B. 

Verkehrstechnik, Energieversorgung, Medizintechnik, Raumfahrt, Militär, teilweise im Banken- und 

Versicherungswesen) Anwendung. Dies beruht hauptsächlich auf der guten Prüfbarkeit und Wartbarkeit des Codes 

und der klaren Zuordnung der Variablen. So ist die 2005 eingeführte Betriebsleittechnik IV der 

Transrapid-Versuchsanlage Emsland in Pascal programmiert. 

Eine pascalähnliche Notation wird von jeher in der Informatik und Mathematik zur Darstellung von Algorithmen 

benutzt. Aus didaktischen Gründen, es seien hier die Typstrenge, hohe Fehlersicherheit und frei verfügbare 

portierbare Pascalcompiler (Free Pascal, GNU Pascal) genannt, wird im aktuellen Informatikunterricht Pascal 

ebenfalls häufig eingesetzt. Im Hobby-Bereich erlangte Pascal zeitweilig eine sehr weite Verbreitung, die jedoch mit 

neueren Microsoft-Windows-Versionen wieder zurückging. 

Datentypen 

Pascal kennt als einfache Datentypen char, boolean, integer, real und ordinale Datentypen. In einigen Dialekten 

wurden die einfachen numerischen Datentypen erweitert, um passende Wortlängen abzudecken. Strukturierte 

Datentypen sind array, record, set (Mengen) und file. Der Datentyp text entspricht der Definition file text = file of 

char; 

Programmstrukturen 

Charakteristisch für Pascal ist das Konzept der Verschachtelung von Prozeduren und Funktionen. Im 

Deklarationsteil einer Prozedur oder Funktion können andere Prozeduren und Funktionen auftauchen. Dabei gibt es 

klar verständliche Prinzipien über die Sichtbarkeit von Deklarationen in übergeordneten Funktionen und Prozeduren. 


Kontrollstrukturen sind if then else, case (in Dialekten mit einem else oder otherwise versehen), for, repeat, while 

und goto. Da Pascal der strukturierten Programmierung dient, soll das goto lediglich strukturerhöhend eingesetzt 

werden. Pascal unterstützt in seiner Urform keine Anweisungen, mit denen Prozeduren oder Schleifen hart verlassen 

werden können. Als strukturerhöhendes goto werden Sprünge ans Ende von Prozeduren oder unmittelbar hinter 

Schleifenenden akzeptiert, sofern sich dadurch umfangreiche Konstruktionen schlecht lesbarer if-Anweisungen oder 

undurchschaubarer boolescher Ausdrucke vermeiden lassen. Viele Pascal-Compiler erlauben keine goto, die zu 

instabilen Systemzuständen führen, z. B. der Sprung in den Anweisungsblock einer Schleife oder eines if.


Nachteile 

Da die Sprache als Lehrsprache konzipiert war, wies das Standard-Pascal einige Merkmale auf, die den 

kommerziellen Einsatz erschwerten: Das Konzept für Dateizugriffe („file I/O“) war nicht mächtig, die 

Laufzeitbibliothek wenig umfangreich, und Zeichenketten konnten nur über Umwege (packed array) direkt im Code 

verwendet werden. Das führte dazu, dass praktisch jede kommerzielle Implementierung hierzu eigene Lösungen 

anbot, was zunächst (ähnlich wie die Diversifizierung bei C) zu eigenen Pascal-Dialekten und damit zu 

Kompatibilitätsproblemen führte. Mit der monopolartigen Dominanz der Borland Turbo-Pascal-Produkte 

verschwanden diese Unterschiede fast vollständig. 

Ein anderer wesentlicher Nachteil war, dass eine Modularisierung im Sinne getrennter Compilierung nicht 

vorgesehen war – was mit der Weiterentwicklung Modula-2 geändert wurde. Plattformspezifische 

Implementierungen sahen dafür eigene Lösungen vor (z. B. die Units von Turbo-Pascal, oder später die Module in 

ANSI/ISO Extended Pascal). 

Compiler 

Der erste Pascal-Compiler selbst entstand auf der CDC Cyber 6000 der ETH Zürich. Daraus entstand dann Pascal 

6000, das als erste operative Version eines Compilers der Sprache gesehen werden kann. 

Ein zweiter Pascal-Compiler – der P4 „Portable Pascal Compiler“ von Urs Ammann, Kesav Nori und Christian 

Jacobi – stammte ebenfalls von der ETH Zürich. Der P4 erzeugte eine plattformunabhängige, als Assemblersprache 

ausgelegte Zwischensprache, den P-Code, der durch eine sogenannte virtuelle Maschine (ein Programm) 

interpretiert wird. Später entstanden dann Compiler, die auf dem P4 basierten. Die verbreitetste Version wurde unter 

dem Namen UCSD Pascal bekannt, das auf vielen Systemen implementiert wurde, u. a. auf Apple II und Texas 

Instruments TI-99/4A und wesentlich zur Verbreitung der Sprache sowohl (zuerst) in den Vereinigten Staaten, später 

auch in Europa beitrug. Im Mai 2006 wurden die Quelltexte von UCSD Pascal freigegeben. 

Bei den meisten Pascal-Compilern handelte es sich um einen One-Pass-Compiler, d. h. der Compiler muss die 

Quelle nur ein einziges Mal lesen und analysieren. Das Design der Sprache war so gehalten, um genau das zu 

ermöglichen. Bei der damaligen geringen Geschwindigkeit der Rechner war dies ein großer Vorteil. 

Unterschiede zu C 

• Sehr hohe Prozesssicherheit – Da Pascal sowie der Quasi-Standard Borland/Turbo-Pascal eine strikte Trennung 

unterschiedlicher Typen vorsehen, kommen „versteckte/automatische“ Typumwandlungen, anders als in C, 

praktisch nicht vor. Insbesondere bei der Übergabe von Daten (z. B. aus externen Dateien, aber auch innerhalb 

des Programms) an Funktionen oder Prozeduren kann der Compiler schon beim Compilieren die Korrektheit der 

Typen kontrollieren (gleiches gilt für Array-Grenzen, Integer-Überlauf, Wrap-Around-Fehler, Stack-Überlauf u. 

ä., die in anderen Programmiersprachen wie z. B. C/C++ häufig subtile und schwer zu lokalisierende 

(Laufzeit-)Fehler erzeugen). 

• keine nullterminierten Zeichenketten – Standard Pascal hatte zwar Zeichenketten-Literale, aber keinen Typ 

string (s. oben). In einigen späteren Versionen werden Zeichenketten nicht durch ein Null-Byte terminiert, 

sondern es wird die Länge im ersten Byte String[0]) gespeichert und über die Funktion length() 

abgefragt. Somit beginnt das erste Nutzzeichen bei String[1]. Dies hatte eine sehr schnelle Verarbeitung zur 

Folge, aber auch den Nachteil, dass Zeichenketten nicht beliebig lang sein konnten. In vielen Implementierungen 

(z. B. Turbo Pascal) war für die Speicherung der Zeichenkettenlänge ein Byte vorgesehen, so dass die Länge auf 

255 Zeichen begrenzt ist. Größere Zeichenketten mussten selbst definiert werden (z. B. als Array of char), sofern 

sie nicht (wie z. B. in Borland Pascal 7) durch die Compilerhersteller bereits implementiert wurden. Im Extended 

Pascal-Standard wurden Zeichenketten als Scheme-Typ definiert. Auch hier muss die Kapazität angegeben 

werden, sie wird aber in runde Klammern geschrieben, und es gibt keine formale Längenbeschränkung: 

String(10240).


• strikte Trennung zwischen Funktionen und Prozeduren – Pascal trennt strikt zwischen einer Funktion 

(Rückgabewert) und einer Prozedur (kein Rückgabewert, Typ void in C). Eine Funktion darf nicht als Prozedur 

aufgerufen werden – d. h. der Rückgabewert muss stets entgegengenommen werden. Seit Turbo Pascal 4.0 (1991) 

ist dies jedoch möglich: Funktionen können auch ohne Entgegennahme des Funktionsergebnisses aufgerufen 


• Deklarationen – Variablen und Typdefinitionen dürfen nicht innerhalb der Implementierung einer 

Funktion/Prozedur (zwischen BEGIN und END) deklariert werden – dies muss in einem speziellen Block im 

Definitionsteil geschehen. Anders als C erlaubt Pascal die Deklarationen lokaler Funktionen bzw. Prozeduren, 

was die Erweiterung des Sprachumfanges durch den Benutzer erheblich vereinfacht. 

• Bezeichner – In Pascal ist die Groß-/Kleinschreibung bei Bezeichnern (Typen, Konstanten, Variablen, 

Funktionen/Prozeduren) irrelevant. Programmfehler durch Tippfehler z. B. Max statt MAX werden dadurch 

vermieden. 

• Semikolon – Das Semikolon wird nicht wie in C als Befehlsabschluss interpretiert, sondern als Trennzeichen 

zwischen Anweisungen. Vor einem END oder UNTIL kann es somit weggelassen werden. Vor einem ELSE darf 

es in der Regel gar nicht stehen, da sonst der IF-Zweig als abgeschlossen angesehen werden würde. Ein Fall, bei 

dem es vor dem ELSE steht (und stehen muss), ist am Ende einer CASE-Auflistung. 

• Delimiter – Für Zeichenketten-Literale und Zeichen-Literale wird dasselbe Begrenzungszeichen (Delimiter), 

nämlich der Apostroph, verwendet. 

• Zuweisungen – Zuweisungen an Variablen werden durch die Sequenz := definiert, das Gleichheitszeichen allein 

dient dem Vergleich. Damit werden „mathematisch falsche“ Ausdrücke z. B. i = i + 1 vermieden. 

• Operatoren – Pascal verwendet die Operatoren and, or, not, div (nur für Integer, bei Real ist es /), mod und 

anstatt der C-Operatoren &&, ||, !, /, % und !=. Die „Short Circuit“-Funktionalität von && und || in C (sobald das 

Ergebnis feststeht, nämlich wenn der linke Teil beim and FALSE beziehungsweise beim or TRUE ist, wird der 

rechte nicht mehr ausgewertet) schloss N. Wirth explizit aus, da compilerinterne Optimierungsvorgänge die 

Reihenfolge der Auswertung verändern können. Spätere Pascalversionen implementierten eine lokal oder global 

zuschaltbare „Short Circuit“-Funktionalität, so dass der Programmierer im Einzelfall entscheiden kann, welche Art 

der Auswertung er wünscht. In Standard-Pascal gibt es keine Bitoperationen für Integer (wie &, |, ^ und ~ von C), 

aber stattdessen den Typ set of (mit den Operatoren *, + und - für Durchschnitt, Vereinigung und 

Mengendifferenz). 

• strenge Typentrennung – u. a. ist Char nicht austauschbar mit Integer, die Umwandlung muss mit den 

Funktionen ord() und chr() durchgeführt werden. Dadurch werden verdeckte (oder ungewollte) Umwandlungen 

vermieden z. B. führt die Anweisung i = 7/2 zu einer Fehlermeldung, wenn i vom Typ Integer = Ganzzahl ist da 

7/2 = 3.5 keine Ganzzahl ist. Spätere Pascalversionen (z. B. Turbo Pascal) führten zusätzlich „explizite“ 

Typumwandlungen, sog. „type casts“, ein, so dass z. B. mit longint(i) der Wertebereich der Ganzzahlvariablen i 

erweitert oder eingeschränkt werden konnte. In Standard-Pascal musste dafür ein Umweg über (den Missbrauch 

von) Variantenrecords (union in C) genommen werden. 

Standards 

Es gibt drei Standards, die sich auf Pascal beziehen: 

1. Standard Pascal: ANSI/IEEE770X3.97-1993 oder ISO 7185:1990; 

2. Extended Pascal: ANSI/IEEE770X3.160-1989 oder ISO/IEC 10206:1991; 

3. sowie einen Entwurf zu „Object-Oriented Extensions to Pascal“. 

Allerdings sind nur die wenigsten Compiler zu diesen Standards vollständig kompatibel. Diese Tatsache verleitete 

Scott A. Moore zu der bissigen Bemerkung „Pascal is, unfortunately, very much a great improvement on its 

successors“ („Pascal ist leider so ziemlich eine große Verbesserung seiner Nachfolger“ – damals bereits ein 

geflügelter Satz, der schon früher über ALGOL, welches auch C und C++ wesentlich beeinflusst hat, oft gesagt


worden war). 

Selbst großen Compilern wie Delphi oder FreePascal fehlen bis heute einige Elemente aus Standard Pascal, während 

Extended Pascal von kaum einem unterstützt wird. Lediglich Prospero Pascal ist vollständig kompatibel zu Extended 

Pascal, während auch GNU Pascal vollständige Kompatibilität anstrebt. 

Implementierungen (Compiler, Interpreter und IDEs) 

Pascal hatte von Anfang an im universitären Bereich sehr großen Erfolg, was sich u. a. auch in der 

Programmiersprache Ada niederschlug, die sehr stark an der Syntax von Pascal angelehnt ist. Ebenfalls fand es weite 

Verbreitung, auch im kommerziellen Bereich, mit den Produkten der Firma Borland Turbo Pascal, Borland Pascal 

und Delphi. Diese Versionen sind durch starke Erweiterungen des ursprünglichen Sprachstandards gekennzeichnet. 

Die Objektorientierung wurde dabei mit Version 5.5 eingeführt. 

Heute gibt es einige freie Implementationen: 

• Free Pascal – Ein unter der GNU Lesser General Public License stehendes Open-Source-Projekt, das sich zum 

Ziel gesetzt hat, einen freien 32/64-Bit-Compiler zu erzeugen, der 100-prozentig kompatibel zu Turbo Pascal und 

Delphi sein soll und mittlerweile eine leichte Portierung von Pascal-Programmen auf fast alle gängigen 

Betriebssysteme und Hardwareplattformen ermöglicht. 

• GNU Pascal – Ein Pascal-Compiler, der als Frontend zur GNU Compiler Collection konzipiert ist. Es ist kein 

Bestandteil der GCC selbst, ist aber durch die Verwendung der GCC plattformunabhängig. Die Entwicklung von 

GPC hat sich zuletzt verzögert. 

• Virtual Pascal – Diese inzwischen freie Implementierung eines Borland-kompatiblen Pascal-Compilers für OS/2 

wurde auch auf andere Plattformen portiert, wird aber seit 2005 nicht mehr weiterentwickelt. 

Integrierte Entwicklungsumgebungen: 

• Lazarus – Eine Entwicklungsumgebung für Free Pascal, die auch verschiedene Komponenten zur Verfügung 

stellt. Die IDE ist sehr Delphi-ähnlich gestaltet und verwendet unter Unix das GTK+ als Grafik-Toolkit, unter 

Windows (win32/win64/wince) setzt es auf der nativen API auf, und auf Apple Betriebssystemen kann wahlweise 

die native Carbon-API oder das X-Window-System verwendet werden. Darüber hinaus unterstützt Lazarus Cross 

Compiling, so dass auch Software für weitere Plattformen wie Windows CE, OS/2, Palm OS oder Nintendo DS 

entwickelt werden kann. Lazarus ist noch nicht fertiggestellt, in kurzen Abständen werden aber neue 

Betaversionen veröffentlicht, die – je nach Plattform in unterschiedlichem Maße – einen wachsenden Teil der 

geplanten Funktionalität implementieren. 

• Dev-Pascal – Eine unter Windows laufende IDE, die auf Free-Pascal oder GNU-Pascal als Compiler aufsetzen 

kann. Wird nicht mehr weiterentwickelt. 

Hallo Welt 

Das Beispielprogramm Hallo Welt sieht in Pascal folgendermaßen aus: 

program Hallo (output); 

begin 

end. 

writeln('Hallo Welt'); 

oder in neueren Pascal-Versionen sieht das Programm so aus: 

program Hallo; 

begin 

end. 

writeln('Hallo Welt');


Ein Detail am Rande: In manchen alten Beispielen findet man ein READLN nach dem WRITELN-Befehl. Das war 

nur notwendig, weil die I/O-Architektur der CDC-Cyber 6000, auf der Wirth den ersten Pascal-Compiler 

entwickelte, das benötigte, um die internen Puffer zu leeren – sonst wäre im interaktiven Betrieb keine Ausgabe zu 

sehen gewesen. IDEs konnte man mit diesem READLN zwingen, am Ende der Programmausführung nicht sofort 

wieder in den Editor-Modus umzuschalten, was die Ausgabe bei manchen IDEs (z. B. Turbo-Pascal) sonst hätte 

verschwinden lassen. Im Batch-Betrieb war das ohnehin nie notwendig. 

Weiterentwicklungen 

• Oberon, Oberon-2 

• POW! - basiert auf Oberon und Pascal 

• Component Pascal – basiert auf Oberon 

• Borland Delphi und Kylix – Objektorientiertes Pascal als Weiterentwicklung von Borland Pascal, nun CodeGear. 

• RemObjects Chrome, Oxygene, nun lizenziert als Delphi Prism von CodeGear 

• PocketStudio 

Literatur 

• Kathleen Jensen, Nicolaus Wirth: Pascal User Manual and Report. ISO Pascal Standard. Broschiert, 266 Seiten, 

Springer-Verlag, 4th ed. 1991, ISBN 3-540-97649-3. 

• Steven Pemberton und Martin Daniels, Ellis Horwood: Pascal Implementation: The P4 Compiler and Interpreter 

[1] , ISBN 0-13-653031-1. 

Weblinks 

• ISO-Pascal Übersichtseite. Sprachreferenz, Pascal-Grammatik, Geschichte, etc. (engl.) [2] 

• UCSD-Pascal Source-Code (engl.) [3] 

Referenzen 

[1] http:/ / homepages. cwi. nl/ ~steven/ pascal/ 

[2] http:/ / www. moorecad. com/ standardpascal/ 

[3] http:/ / www. bitsavers. org/ bits/ UCSD_Pascal/

PEARL 106 

PEARL 

Bereich Informationstechnik 

Regelt Programmiersprache PEARL 

Kurzbeschreibung 

DIN 66253 

PEARL 90 (DIN 66253-2), Mehrrechner-PEARL (DIN 66253-3) 

Letzte Ausgabe 04.1998 (Teil 2), 01.1989 (Teil 3) 

ISO 

PEARL [pɜːɹl] ist eine Echtzeit- und Multitasking-Programmiersprache nach DIN 66253. Sie findet besonders unter 

RTOS-UH Anwendung. PEARL steht für Process and Experiment Automation Realtime Language und hat nichts 

mit der Scriptsprache Perl zu tun. 

Anwendung 

PEARL wird unter anderem verwendet in der Programmierung von Prozessrechnern bei Energieversorgern, so zum 

Beispiel bei den Stadtwerken Hannover. [1] 

Weiterhin wird PEARL an vielen Hochschulen zur Ausbildung in Programmierung von Echtzeitsystemen genutzt. [2] 

Literatur 

• Peter Holleczek (Hrsg), Birgit Vogel-Heuser (Hrsg): Echtzeitaspekte bei der Koordinierung Autonomer Systeme, 

Springer Berlin 2005, ISBN 3-540-29594-1 

• B. Reißenweber: Programmieren mit PEARL, R. Oldenbourg Verlag München Wien 1988, ISBN 3-486-20512-9 

• L. Frevert: Echtzeit-Praxis mit PEARL, B.G. Teubner, Stuttgart, 1985 - ISBN 3-519-02475-6 PDF [3] 

• J. Brandes, S. Eichentopf, P. Elzer, L. Frevert, V. Haase , H. Mittendorf, G. Müller, P. Rieder: PEARL, The 

Concept of a Process and Experiment Oriented Programming Language; elektronische datenverarbeitung, 10 

(1970), S.429-442 

• K. H. Timmesfeld, B. Schürlein, P. Rieder, K. Pfeiffer, G. Müller, K. Kreuter, P. Holleczek, V. Haase, L. Frevert, 

P. Elzer, S. Eichentopf, B. Eichenauer, J. Brandes: PEARL - Vorschlag für eine Prozess- und 

Experimentautomatisierungssprache. Gesellschaft für Kernforschung mbH, Karlsruhe, PDV-Bericht KfK-PDV 1, 

April 1973 

Weblinks 

• Beschreibung von PEARL [4] 

• [news://hannover.uni.comp.rtos-uh Newsgroup hannover.uni.comp.rtos-uh] 

• Literatur über PEARL (Programmiersprache) [5] im Katalog des Bibliotheksservice-Zentrums 

Baden-Württemberg (BSZ) 

• Fachgruppe Echtzeitsysteme der GI [6]

PEARL 107 

Referenzen 

[1] iX - Magazin für professionelle Informationstechnik, Ausgabe 4/1999, S. 120 

[2] http:/ / www. irt. uni-hannover. de/ pearl/ prllehre. html 

[3] http:/ / www. irt. uni-hannover. de/ pub/ pearl/ PEARLFrev. pdf 

[4] http:/ / www. irt. uni-hannover. de/ pearl/ 

[5] http:/ / pollux. bsz-bw. de/ REL?PPN=209200421 

[6] http:/ / www. real-time. de 

Perl (Programmiersprache) 

Perl 

Paradigmen: prozedural, modular, teilweise objektorientiert 


Entwickler: Larry Wall, Perl Porter 

Aktuelle Version: 5.10.1 (23. August 2009) 

Typisierung: schwach, dynamisch, implizit 

Einflüsse: Awk, BASIC-PLUS, C, C++, LISP, Pascal, Python, Sed, Unix-Shell 

Beeinflusste: PHP, Ruby, Python, JavaScript 


Lizenz: GPL und Artistic License 

www.perl.org [1] 

Perl [pɜɹl] ist eine freie, plattformunabhängige und interpretierte Programmiersprache (Skriptsprache), die mehrere 

Programmierparadigmen unterstützt. 

Der Linguist Larry Wall entwarf sie 1987 als Synthese aus C, awk, den Unix-Befehlen und anderen Einflüssen. 

Ursprünglich als Werkzeug zur Verarbeitung und Manipulation von Textdateien insbesondere bei System- und 

Netzwerkadministration vorgesehen (zum Beispiel Auswertung von Logdateien), hat Perl auch bei der Entwicklung 

von Webanwendungen und in der Bioinformatik weite Verbreitung gefunden. Traditionell stark ist Perl auch in der 

Finanzwelt, bei der Verarbeitung von Datenströmen verschiedenartiger Nachrichtenquellen. Hauptziele sind eine 

schnelle Problemlösung und größtmögliche Freiheit für Programmierer. Die Bearbeitung von Texten mit Hilfe 

regulärer Ausdrücke sowie viele frei verfügbare Module, die an einem zentralen Ort (CPAN) gesammelt werden, 

sind Stärken der Sprache.


Geschichte 

Entstehung 

Larry Wall war als Administrator und Programmierer bei dem 

Unternehmen Unisys angestellt, wo er seit März 1987 daran beteiligt 

war, unter dem Namen blacker ein sicheres Netzwerk für die NSA zu 

entwickeln. Er erhielt mehrere Aufträge, Werkzeuge zur Überwachung 

und Fernwartung der entstehenden Software zu schaffen. Eine 

Hauptaufgabe war dabei, übersichtliche Berichte aus verstreuten 

Logdateien zu erzeugen. Da ihm die vorhandenen Sprachen und 

Werkzeuge dafür zu umständlich erschienen, entwickelte er mit Hilfe 

seines damaligen Teamkollegen Daniel Faigin und seines Schwagers 

Mark Biggar schrittweise eine eigene Sprache, um seine Aufgaben zu 

lösen. 

Dabei griff er auch auf sein Wissen und seine Erfahrung als Linguist 

zurück und entwarf Perl nahe an den menschlichen 

Sprachgewohnheiten. Dies drückt sich in minimalen Voraussetzungen 

für Einsteiger, einer starken Kombinierbarkeit der Sprachelemente und 

einem reichen Wortschatz aus, der auch Befehle zulässt, deren 

Bedeutungen sich überschneiden. Wall sieht darin die Bedürfnisse 

eines Praktikers nach Freiheit und intuitivem Ausdruck verwirklicht. 

Larry Wall entwarf Perl 

Gemäß diesem praktischen Ansatz borgte sich Perl seinen Wortschatz und seine logischen Strukturen von den in den 

1980er Jahren unter Unix verbreiteten Sprachen und Werkzeugen, was das Erlernen vereinfachte, aber auch die 

Unix-Philosophie umkehrte. Unix und seine Systembefehle waren kompiliert und meist in C geschrieben. Diese 

Befehle waren logische Einheiten und sollten genau eine Aufgabe beherrschen: „Do one thing and do it well“ („Mach 

eine Sache und mach’ sie gut“). Interpretierte Shell-Skripte kombinierten schnell und einfach die Befehle, die 

untereinander ihre Ergebnisse durch Pipes weiterreichen konnten. Perl verletzt diese Philosophie, indem es diese 

Befehle zum Bestandteil der Programmiersprache macht, also C und Shell vereint und die vorhandenen Befehle und 

Werkzeuge übergeht. 

Dies wurde notwendig, weil Shell-Skripte für komplexe Aufgaben ungeeignet waren. Ihr Ablauf ist sehr einfach, sie 

können Daten nur eingeschränkt zwischenspeichern und die Pipes sind Nadelöhre für den Datenaustausch. 

Andererseits erlauben sie einen wesentlich kompakteren Programmierstil, da die Benutzung eines UNIX-Werkzeugs 

viele Zeilen C-Quelltext ersetzen kann. 

Um die Vorteile beider Programmierarten nutzen zu können, schuf Wall eine Kombination aus C und Werkzeugen 

wie sed, awk, grep und sort. Er fügte Eigenschaften der Bourne Shell, in geringem Maße auch Elemente aus Pascal 

und BASIC, sowie eigene Ideen dazu [2] . Diese Fusion ermöglichte kurze, mächtige Programme, die man schnell 

schreiben und jederzeit auch testen konnte, ohne sie kompilieren zu müssen, was die Entwicklung ebenfalls 

beschleunigte. Später wurden weitere Fähigkeiten von Sprachen wie LISP, Smalltalk, Python oder Ruby „importiert“. 

Name 

Der Name Perl bezieht sich auf ein Zitat aus dem Matthäus-Evangelium (Mt 13,46 [3]), in dem Jesus das 

Himmelreich mit dem Bild eines Händlers beschreibt, der seinen gesamten Besitz verkaufen will, um eine kostbare 

Perle zu erwerben. Noch vor der Veröffentlichung wurde der Name von „Pearl“ in „Perl“ geändert, da es bereits eine 

Programmiersprache namens PEARL gab. Allgemein verbreitet und von Larry Wall akzeptiert sind auch die 

Backronyme Practical Extraction and Report Language (zweckmäßige Extraktions- und Berichtssprache) und


Pathologically Eclectic Rubbish Lister (krankhaft stilmischender Blödsinnsauflister). Die Schreibweise „Perl“ 

bezeichnet die Sprache, „perl“ dagegen das Programm, das diese Sprache interpretiert. Ferner legt die Perl-Gemeinde 

Wert darauf, dass nicht die Schreibweise „PERL“ verwendet wird. [4] 

Perl 1 bis 4 

Am 18. Dezember 1987 publizierte Larry Wall sein Programm im 

Usenet als Perl 1.0, das damals noch eine mächtigere Shell war, die gut 

mit Texten und Dateien umgehen, andere Programme steuern und gut 

lesbare Berichte ausgeben konnte. Bereits am 5. Juni im Jahr darauf 

erschien die Version 2.0 mit grunderneuerter und erweiterter 

Regex-Engine und einigen weiteren Verbesserungen. Am 18. Oktober 

1989 folgte Perl 3, das mit binären Daten umgehen konnte und auch 

Netzwerkprogrammierung ermöglichte. Als neue Lizenz wurde die 

GPL gewählt. 

Larry Wall war zu dieser Zeit Angestellter der 

Fast unverändert war es ab dem 21. März 1991 als Perl 4 erhältlich, jedoch nun wahlweise unter der GPL oder der 

von Larry Wall entwickelten Artistic License. Der eigentliche Grund für die neue Version war aber das gleichzeitig 

erschienene Kamelbuch, das als Referenz für den aktuellen, als Version 4 markierten Stand, veröffentlicht wurde. 

Bis dahin waren die seit Perl 1 verfügbaren UNIX-man-pages die einzige verfügbare Perl-Dokumentation. Diese 

bieten zu jedem Thema eine fundierte und umfangreiche Abhandlung, aber keinen einfachen Einstieg für 

Perl-Anfänger. 

Diese Lücke sollte das von Randal L. Schwartz, Larry Wall und Tom Christiansen verfasste Buch schließen. Es 

erschien im O’Reilly Verlag, der mit diesem und weiteren Titeln als renommierter Fachverlag für Programmierer 

bekannt wurde. Perl-Bücher von O’Reilly wurden die maßgeblichen Perl-Publikationen, was sich erst im neuen 

Jahrtausend etwas relativierte. Der Verlag betreibt auch unter der Internetadresse perl.com das meistbesuchte 

Online-Magazin für Perl-Programmierung und veranstaltet mit der TPC (The Perl Conference – heute OSCON) die 

größte Perl-Konferenz. O’Reilly profitierte von Perls wachsender Popularität, und im Gegenzug bezahlte Tim 

O’Reilly seinem Freund Larry Wall in den folgenden Jahren ein festes Gehalt, der sich so, ohne weitere Pflichten 

oder Vorgaben, der Weiterentwicklung der Sprache widmen konnte. 

1993, als Perl die Version 4.036 erreichte, brach Larry Wall die Weiterentwicklung ab, um mit Perl 5 eine 

vollständige Neuentwicklung zu beginnen. 

Perl 5 

Perl 5.0 wurde am 18. Oktober 1994 veröffentlicht und war der bisher 

größte Fortschritt für die Sprache. Mit Plain Old Documentation 

konnte man nun formatierte Dokumentation in den Quelltext einfügen. 

Auch ließ sich die Sprache ab jetzt durch separate Module erweitern, 

was im folgenden Jahr zur Entstehung des CPAN führte. Dieses große 

Archiv frei erhältlicher Module ist heute selbst ein wichtiger Grund, 

Perl einzusetzen. Eine weitere wichtige Neuerung war die Einführung 

JPL 

CPAN – eines der größten Archive freier 

Software 

von Referenzen, die erstmals eine einfache Erstellung zusammengesetzter Datenstrukturen erlaubte. 

Mit Version 5 wurde es auch möglich, objektorientiert in Perl zu programmieren. Dabei wählte Larry Wall einen 

ungewöhnlichen Weg und leitete die dafür verwendete Syntax fast ausschließlich aus vorhandenen Sprachelementen 

ab (Packages, Package-Funktionen und Package-Variablen sowie den neuen Referenzen). Lediglich die Funktion 

bless() zum Anlegen eines Objektes und der Pfeil-Operator (->) zum Aufruf von Methoden kamen hinzu. Es entstand 

auch XS, eine Schnittstellenbeschreibungssprache, die es ermöglicht, Perl-Programme mit anderen Sprachen zu


erweitern oder mit Perl-Programmen beliebige Software oder Hardware anzusprechen. 

Seit der Veröffentlichung von Perl 5 beteiligte sich Larry Wall kaum noch an der Entwicklung der Sprache. Dies 

übernahmen freiwillig Perl-begeisterte Programmierer, die sogenannten Perl 5 Porter, die über die im Mai 1994 

gegründete p5p-Mailingliste kommunizieren, aber auch zunehmend über einen eigenen Bug- und Request-Tracker 

(RT) über Fehlerbehebungen und neue Funktionen der Sprache entscheiden. Dabei übernimmt je Version ein 

sogenannter Pumpking die Leitung. Der Begriff Perl Porter entstammt der ursprünglichen Aufgabe der p5p-Liste, 

die Portierung von Perl auf andere Betriebssysteme zu koordinieren. 

In den Jahren nach Version 5.0 wurde nicht nur Perl auf Macintosh und Windows portiert, sondern es verschob sich 

auch die Nummerierung der Versionen. Da sich an der Syntax nichts Wesentliches änderte, beließ man die 5 und 

erhöhte bei größeren Meilensteinen die erste Nachkommastelle, verwendete aber zusätzliche Nummern um die 

Zwischenschritte zu zählen. Da Perl erst ab 5.6 mit Versionsnummern, die mehrere Kommata enthalten, umgehen 

konnte, wurden sie bis dahin z. B. Perl 5.001 oder Perl 5.001012 geschrieben. Ab 5.6 wurde auch das 

Versionsschema von Linux übernommen, bei dem gerade Nummern auf Fehlerfreiheit gepflegte Benutzerversionen 

hindeuten und ungerade auf Entwicklerversionen, in die neue Funktionen einfließen. Serien von Benutzerversionen 

(z. B. 5.8.x) werden untereinander binär kompatibel gehalten, was bedeutet, dass ein für Perl 5.8.7 kompiliertes 

Binärmodul auch mit 5.8.8, nicht jedoch mit 5.10 oder 5.6.1 funktioniert. 

Perl 5.6 

Diese Version brachte einige neue experimentelle Fähigkeiten, die erst später ausreiften, wie Unicode und UTF-8, 

Threads und cloning. Auch 64-Bit-Prozessoren konnten nun genutzt werden. Sprachlich fügte diese von Gurusamy 

Sarathy geleitete Reihe vor allem lexikalisch globale Variablen (mit our) und eine Vektorschreibweise, die den 

Vergleich mehrstelliger Versionsnummern erlaubt, sowie die Spezialvariablen @- und @+, ein. 

Perl 5.8 

Mit der von Nicholas Clark betreuten Reihe 5.8.x wurden vor allem die Probleme mit Unicode und den Threads 

behoben, aber auch die Ein-/Ausgabe (IO), Signale und die numerische Genauigkeit wurden entscheidend verbessert. 

Perl 5.10 

Neben verringertem Speicherverbrauch und einer erneuerten und nun auch austauschbaren Regex-Maschine brachte 

diese Version unter der Führung von Rafaël Garcia-Suarez vor allem Neuerungen, die dem Entwurf von Perl 6 

entstammen und deren Gebrauch entweder einzeln oder kollektiv mit use feature ':5.10'; angemeldet werden muss. 

Hierzu zählen say, given und when (analog zur switch-Anweisung in C), der smartmatch-Operator (~~), der defined 

or-Operator (//) und state-Variablen, welche die Erzeugung von Closures vereinfachen. Weitere nennenswerte 

Neuheiten umfassen den verlagerbaren Installationspfad, stapelbare Dateitestoperatoren, definierbare lexikalische 

Pragmas, optionale C3-Serialisierung der Objektvererbung und field hashes (für „inside out“-Objekte). Die 

Regex-Engine arbeitet nun iterativ statt rekursiv, was nun rekursive Ausdrücke ermöglicht. Komplexe Suchanfragen 

können nun auch verständlicher und weniger fehleranfällig durch named captures formuliert werden. Die 

Spezialvariablen $# und $* sowie die Interpreterschnittstellen perlcc und JPL wurden entfernt. 

Aktuelle Versionen 

Auch wenn die neueste Benutzerversion 5.10.1 lautet, werden derzeit die Versionsreihen 5.8.x und 5.6.x weiterhin 

gepflegt, da sie von den meisten Programmen und Webservern verwendet werden. Deswegen gelten sowohl 5.8.9 

und geringer auch 5.6.2 als aktuelle Versionen. 5.005 und 5.004 sind veraltet, wichtige Module funktionieren mit 

ihnen aber weiterhin, wobei 5.005 noch minimal weitergepflegt wird. Derzeitige Änderungen finden im 

Entwicklerzweig 5.11 statt, der nicht für allgemeine Benutzung bestimmt ist. Die nächste Perlversion wird 5.12 und 

nicht Perl 6 sein, welches ein Langzeitprojekt ist. Die Sprache, der Interpreter und die umgebende Infrastruktur 

sollen vollständig neu gestaltet werden.


Perl 6 

Am 19. Juli 2000 auf der TPC 4 [5] wurde Perl 6 als die Version der 

Perl-Gemeinschaft angekündigt. Nachdem Larry Wall mehrere hundert 

Vorschläge auswertete und thematisch sortierte, schrieb er je Thema 

einen Überblick seiner Vorstellungen (Apocalypse genannt), der nach 

Diskussionen in den Mailinglisten von Damian Conway zu einer 

detaillierten Exegese formuliert wird. In den folgenden Jahren wurde 

die Sprache in kleinerem Kreis (meist über die p6l Mailingliste) 

weiterentwickelt und dabei der aktuelle Stand in wesentlich knapperen 

Synopsen festgehalten. 

Dabei wird die Sprache entrümpelt und mit neuen Fähigkeiten 

ausgestattet [6] . Unter anderem wurde die Objektorientierung komplett 

neu gestaltet und funktionale Programmierelemente wie 

Hyperoperatoren und Junctions eingeführt. Makros werden Sourcefilter 

ablösen und die neu systematisierten und erweiterten regulären 

Ausdrücke lassen sich zu ableitbaren Grammatiken zusammenfassen, 

was eine lex-ähnliche Programmierweise erlaubt. Sie werden mit dem 

smart match-Operator ~~ angewendet der je nach Kontext 

verschiedene Arten von Daten, Datenstrukturen und auch Inhalte von 

Symboltabellen vergleichen kann. Die Neugestaltung der Syntax ist in 

Auch Damian Conway ist an der Neugestaltung 

der Sprache beteiligt. 

großen Teilen abgeschlossen, lediglich Feinheiten werden noch geändert. Nur einzelne Bereiche wie z. B. Threads 

wurden aber noch gar nicht abgedeckt. 

Als Interpreter für Perl 6 ist eine neue registerbasierte virtuelle Maschine namens Parrot in Entwicklung, die neben 

Perl 6 noch viele andere Sprachen kompilieren (in Bytecode übersetzen) und ausführen können soll. Sie wurde von 

Dan Sugalski und Chip Salzenberg entworfen und wird derzeit von Allison Randal und Patrick Michaud betreut, 

wobei letzterer für die Parrot Compiler Tools (PCT) zuständig ist, einem Satz für Parrot geschriebener Werkzeuge, 

der die Erstellung von Parsern beschleunigt. Der auf Parrot und PCT basierende Perl 6-Interpreter nennt sich 

Rakudo. 

Audrey Tang leitet seit Anfang Februar 2005 die Entwicklung des alternativen Perl-6-Compilers namens Pugs in der 

Sprache Haskell. Lange Zeit war Pugs der langsamste aber vollständigste Perl-6-Interpreter und ermöglichte es, 

zahlreiche Details der Sprache vorzuführen, zu testen und nachzubearbeiten. Auch die umfangreiche und in Perl 6 

geschriebene Perl-6-Testsuite entstammt dem Pugs-Quellcode. 

Mittlerweile gibt es neben Rakudo und Pugs weitere Interpreter, Compiler- und Parser-Projekte, mit 

unterschiedlichen Schwerpunkten wie SMOP (Meta-OOP-runloop), elf und gimme5. Die Sprachsyntax ist in der 

STD.pm vollständig mit Hilfe der Perl 6-Regex definiert, die von einigen Interpretern auch zum Parsen eingesetzt 

wird.


Merkmale 

Prinzipien 

Perl wurde für den praktischen Einsatz entwickelt und konzentriert sich daher auf schnelle und einfache 

Programmierbarkeit, Vollständigkeit und Anpassbarkeit. Diese Philosophie drückt sich in den folgenden 

Schlagworten oder Phrasen aus, die meist von Larry Wall stammen. 

Mehrere Wege 

Das bekannteste und grundlegendste Perl-Motto ist „There is more than one way to do it“, kurz TIMTOWTDI oder 

(mit englischer Kontraktion) gesprochen „Tim Toady“. Zu Deutsch: „Es gibt mehr als einen Weg, etwas zu tun“. Perl 

macht im Gegensatz zu Sprachen wie Python weniger Vorgaben und bietet absichtlich für jedes Problem mehrere 

Formulierungs- und Lösungsmöglichkeiten (Syntaktischer Zucker). Zum Beispiel kann man logische Operatoren als 

|| und && (wie in C) oder (mit Bedeutungsnuancen) als or und and (wie in Pascal) schreiben; aber auch zahlreiche 

Befehle mit einem sich überschneidenden Funktionsumfang wie map und for erlauben verschiedene Formulierungen 

für den gleichen Sachverhalt. Einige Befehle wie der Diamant-Operator () bieten verkürzte Schreibweisen für 

bereits vorhandene Funktionalität. Diese Vielfalt wird auch im CPAN sichtbar, wo oft mehrere Module einen sehr 

ähnlichen Zweck erfüllen. 

Ein weiteres Schlagwort, das man auch als Erweiterung von TIMTOWTDI sehen kann, bezeichnet Perl als die erste 

postmoderne Programmiersprache. Damit ist gemeint, dass Perl verschiedene Paradigmen vereint und es dem 

Benutzer frei steht, strukturierte, objektorientierte, funktionale und imperative Sprachmerkmale zu kombinieren. 

Einfach und möglich 

Der andere wichtige Merksatz ist Perl makes easy jobs easy and hard jobs possible, was zu deutsch bedeutet Perl 

hält die einfachen Aufgaben einfach und macht (die Lösung) schwierige(r) Aufgaben möglich. Dies beinhaltet zum 

ersten das Ziel, gängige Aufgaben möglichst mit kurzen „fertigen Lösungen“ zu vereinfachen. Zum Beispiel prüft -e 

dateiname die Existenz einer Datei. Einfache Aufgaben einfach zu belassen bedeutet für Perl aber auch, möglichst 

keine vorbereitenden Programmieranweisungen zu verlangen, wie das Anmelden von Variablen oder das Schreiben 

einer Klasse. Zweitens versucht Perl vollständig zu sein und für jedes Problem mindestens die Grundlagen 

bereitzustellen, die eine Lösung möglich machen. Das dritte Ziel, die beiden ersten Ziele nicht kollidieren zu lassen, 

gewinnt mit dem wachsendem Sprachumfang von Perl 6 immer mehr an Bedeutung, wo in Anlehnung an den 

Huffman-Code die Schreibweisen der am häufigsten verwendeten Befehle möglichst kurz gehalten sind, ohne mit 

der Logik der Schreibweise ähnlicher Befehle zu brechen. 

Kontextsensitiv 

In Perl gibt es Befehle, die verschiedene Bedeutungen haben, je nachdem in welchem Zusammenhang sie benutzt 

werden. Derart kontextsensitiv sind Datenstrukturen wie das Array. Wird es einem anderen Array zugewiesen, wird 

dessen Inhalt übergeben; ist der Empfänger ein einzelner Wert (Skalar), erhält dieser die Länge des Arrays. 

Technische Merkmale 

Der Perl-Interpreter selbst ist ein in C geschriebenes Programm, das auf annähernd jedem Betriebssystem 

kompilierbar ist. Vorkompilierte Versionen auf selten verwendeten Systemen wie zum Beispiel BeOS oder OS/2 

sind jedoch nicht immer auf dem neuesten Stand. Der Quellcode umfasst circa 50 MB und enthält auch Perl-Skripte, 

die die Funktion von Makefiles, und der Test-Suite übernehmen. Aktuell ist das kompilierte Programm circa 850 KB 

groß, was aber je nach Betriebssystem, verwendetem Compiler und Bibliotheken variieren kann. 

Perl-Skripte werden in Textdateien mit beliebigem Zeilentrennzeichen gespeichert. Beim Start eines Skripts wird es 

vom Perl-Interpreter eingelesen, in einen Parse Tree umgewandelt, dieser zu Bytecode, welcher dann ausgeführt


wird. Der im Interpreter integrierte Parser ist eine angepasste Version von GNU Bison. 

Strenggenommen ist Perl daher keine interpretierte Sprache, da ein Perl-Programm vor jeder Ausführung kompiliert 

wird. Das führt etwa dazu, dass – anders als bei rein interpretierten Sprachen – ein Programm mit Syntaxfehlern 

nicht startet. 

Verbreitung 

Zu Beginn war Perl ein UNIX-Werkzeug, das besonders auf die Verarbeitung von Textdateien, Steuerung anderer 

Programme sowie zur Ausgabe von Berichten ausgelegt war. Dafür wird es bis heute, nicht nur von 

Systemadministratoren, auf allen verbreiteten Betriebssystemen eingesetzt. Dabei bekam Perl auch den Ruf einer 

glue language („Klebstoff-Sprache“), weil mit Hilfe von relativ schnell geschriebenen Perl-Skripten inkompatible 

Software verbunden werden kann. Bis heute gehört Perl auf allen POSIX-kompatiblen und Unix-ähnlichen Systemen 

zur Grundausstattung. 

Mit der Verbreitung des World Wide Web wurde Perl zunehmend benutzt, um Webserver, Datenbanken und weitere 

Programme und Daten zu verbinden und die Ergebnisse in Form von HTML-Seiten auszugeben. Der Perl-Interpreter 

wird dabei über CGI oder FastCGI vom Webserver angesprochen oder ist direkt im Server eingebettet. (mod_perl im 

Apache, ActiveState PerlEx im Microsoft IIS). Auch wenn für diese serverseitige Skript-Programmierung PHP 

mittlerweile populärer wurde, wird Perl weiterhin von vielen großen und kleinen Seiten und Internetdiensten wie 

Amazon.com, IMDB.com, slashdot.org, MovableType und LiveJournal verwendet. Da Perl-Skripte oft kaum 

erkennbar an vielen wichtigen Stellen arbeiten, wurde Perl auch scherzhaft als das Klebeband bezeichnet, welches 

das Internet zusammenhält. In Perl entstanden auch Frameworks wie Mason, Embperl, Maypole, Catalyst und Jifty, 

die eine sehr schnelle Entwicklung komplexer und leicht veränderbarer Internetseiten erlauben. Auch Wiki-Software 

ist häufig in Perl geschrieben wie z. B. Socialtext das auf Mason basiert, Kwiki, TWiki, ProWiki oder UseMod. 

Auch verbreitete Ticket-Systeme mit Webschnittstelle wie Bugzilla oder RT sind in Perl geschrieben. 

Jedoch sind WWW-Anwendungen weiterhin nur eines der vielen Einsatzgebiete von Perl. Wichtige Perl-Programme 

im E-Mail-Bereich sind SpamAssassin (Spam-Filter), PopFile und open webmail. Zur Systemverwaltung wird Perl 

zum Beispiel in Debconf, einem Teil der Paketverwaltung des Betriebssystems Debian, benutzt. Auch automake, ein 

Teil des GNU Build System, ist in Perl geschrieben. 

Weitere Hauptanwendungsfelder sind das Data-Munging und die Bioinformatik, wo Perl seit etwa 1995 die am 

häufigsten verwendete Sprache war und immer noch bedeutend ist. Gründe hierfür sind wieder die Fähigkeit, 

Informationen in Textform zu verarbeiten, und die Flexibilität und Offenheit der Sprache, die es der internationalen 

Forschergemeinde erlauben, trotz unterschiedlicher Standards der Institute zusammenzuarbeiten. BioPerl ist hier die 

wichtigste Sammlung frei erhältlicher Werkzeuge, die sich vor allem auf das Gebiet der Genomsequenzenanalyse 

konzentriert. Beim Human Genome Project spielte Perl eine wichtige Rolle. 

Auch Desktop-Anwendungen und Spiele wie Frozen Bubble können in Perl geschrieben werden. Programme in Perl 

sind schneller zu entwickeln als mithilfe kompilierter Sprachen. Die heutigen Computer sind schnell genug, diese 

Programme flüssig auszuführen. 

Bereiche, in denen Skriptsprachen wie Perl nicht sinnvoll eingesetzt werden können, sind zum einen Anwendungen 

mit hohen Anforderungen an Hardware-Nähe oder Geschwindigkeit wie zum Beispiel Treiber oder Codecs. Zum 

anderen sollten sie nicht in stark sicherheitskritischen Bereichen (z. B. Flugzeugsteuerung) Verwendung finden, da 

aufgrund der laxen Syntaxprüfung (z. B. fehlendes/sehr schwaches Typsystem) viele Fehler erst zur Laufzeit 

auftreten und eine Verifizierung im allgemeinen nicht möglich ist.


Perl und andere Programmiersprachen 

Für Aufgaben, die mit Perl nur schwierig oder langsam lösbar sind, bietet Perl mit dem Modul Inline [7] eine 

Schnittstelle an, über die Programmteile in anderen Sprachen in ein Perl-Programm eingebunden werden können. 

Unterstützte Sprachen sind u. a. C, C++, Assembler, Java, Python, Ruby, Fortran und Octave[8]. 

Anwendungsgebiete sind z. B.: 

• Rechenintensive Formeln (C, Assembler), 

• Lösung komplexer Probleme mit existierenden Systemen (Octave, Fortran-Bibliotheken) und 

• Zusammenführen von Anwendungen in unterschiedlichen Sprachen („Glue-Funktion“ von Perl). 

Die Anwendung von Inline ist relativ einfach und gut dokumentiert. Bei compilierten Programmteilen führt Inline 

mittels MD5-Kennung Buch über den Versionsstand, wodurch Mehrfachcompilierung des gleichen Codes 

vermieden wird. 

Bei Inline erfordert die Übergabe der Parameter und Rückgabe der Ergebnisse einigen Aufwand. Bei kurzen 

Berechnungen überwiegt dieser Aufwand den Gewinn an Geschwindigkeit. Wird zum Beispiel die 

Mandelbrot-Menge berechnet, indem die Formel über Inline als C-Funktion berechnet, die Iteration 

aber in Perl belassen wird, verlangsamt sich die Programmausführung gegenüber einer reinen Perl Implementierung. 

Wird hingegen auch die Iterationsschleife in C ausgelagert, steigert sich die Performance signifikant. 

Logos 

Als Maskottchen von Perl dient ein Dromedar. Es zierte erstmals den 

Umschlag des auch als Kamelbuch bekannten Referenzwerkes 

Programming Perl. Sein Verleger (Tim O’Reilly) sagte in einem 

Interview scherzhaft als Begründung: Perl ist hässlich und kommt über 

lange Strecken ohne Wasser aus. Das Dromedar ist auf dem 

Programming Republic of Perl Emblem zu sehen, das oft als offizielles 

Perl-Logo angesehen wird und dessen nichtkommerziellen Gebrauch 

O’Reilly gestattet. Andere im Zusammenhang mit Perl benutzte Logos 

sind neben Perlen die aufgeschnittene Zwiebel (Erkennungszeichen der 

Perl Foundation) und der Komodowaran, der die weit verbreitete 

Perl-Distribution ActivePerl von ActiveState schmückt. 

Kritikpunkte 

Tim O’Reilly zählte viele Jahre zu Perls 

wichtigsten Unterstützern 

Häufigster Kritikpunkt an Perl ist seine mangelnde Lesbarkeit. Tatsächlich bietet Perl überdurchschnittlich viele 

Freiheiten, die zu unleserlichem Code führen können (siehe Disziplinen). Andererseits ermöglicht es die gleiche 

Freiheit auch, nahe an der logischen Struktur des Problems oder dem menschlichen Verständnis zu programmieren. 

Die von Perl-Programmierern geschätzte Freiheit, persönlichen Vorlieben nachzugehen, muss bei Projekten, die von 

mehreren Programmierern oder über längere Zeiträume entwickelt werden, durch selbst auferlegte Regeln 

eingeschränkt werden, um spätere Probleme zu vermeiden. Dies erfordert zusätzlichen Kommunikationsaufwand 

oder die Verwendung von Software wie Perl::Critic. 

Einige Teile der Syntax, wie die Objektorientierung und Signaturen, sind zwar einfach und sehr mächtig, werden 

aber häufig gegenüber vergleichbaren Sprachen wie Python oder Ruby als veraltet wahrgenommen und fordern bei 

standardisierten Herangehensweisen, besonders von Perl-Anfängern, zusätzliche Tipp- und Denkarbeit. Diese 

Probleme sollen mit Perl 6 behoben werden oder können mit zusätzlichen, für Perl 5 erhältlichen Modulen 

umgangen werden. 

Weiterhin wird Perl vorgeworfen, es verletze die UNIX-Philosophie (siehe dazu den Abschnitt Entstehung).


Starke Kritik wird auch gegen Perl 6 erhoben, das zu hoch gesteckte Ziele habe und nach 7 Jahren angeblich immer 

noch keine sichtbaren Ergebnisse bringe und statt dessen die Zukunft von Perl (5) lähme. Perl 6 war von Anfang an 

als Langzeitprojekt ausgerufen, das ausschließlich auf nicht immer planbarer Freiwilligenarbeit und kaum auf 

finanzieller Unterstützung beruht. Seine konkreten Ziele zeichneten sich erst im Verlauf der Entwicklung ab, und es 

gab eindeutige Probleme bei der Kommunikation und der Außendarstellung. Allerdings enthält die aktuelle 

Perl-Version 5.10 bereits vielsprechende Neuerungen aus Perl 6, Pugs und Rakudo können große Teile von Perl 6 

ausführen und der Perl 6-rules-Compiler PGE beeindruckte auf Fachkonferenzen als Werkzeug für den Parserbau. 

Syntax 

Freies Format 

Perl erlaubt bedingt formatfreien Quellcode. Das bedeutet, dass Einrückungen und zusätzliche Leerzeichen 

syntaktisch unerheblich sind und auch Zeilenumbrüche nach Belieben eingefügt werden können. Dafür müssen 

Befehle eines Blocks mit Semikolon getrennt werden. Einige Sprachelemente wie Formate, heredocs und 

gewöhnliche reguläre Ausdrücke sind nicht formatfrei. 

Variablen 

Charakteristisch für Perl ist, dass Variablen durch ein Präfix (auch Sigil genannt) gekennzeichnet werden, das ihren 

Datentyp anzeigt. Hier einige Beispiele: 

• $ für Skalare: $scalar 

• @ für Arrays: @array 

• % für Hashes/assoziative Arrays: %hash 

• & für Funktionen (oft optional): &function 

• * für Typeglobs: *all 

Datei-Handles, Verzeichnis-Handles und Formate besitzen kein Präfix, sind aber ebenfalls eigenständige 

Datentypen. Jeder Datentyp hat in Perl seinen eigenen Namensraum. 

Basisdatentypen in Perl sind skalare Variablen, Arrays und Hashes (assoziative Arrays). 

• Skalare sind typlose Variablen für einzelne Werte; es können Strings, Zahlen oder Referenzen auf andere Daten 

oder Funktionen in ihnen gespeichert sein. 

• Arrays fassen mehrere Skalare unter einem Variablennamen zusammen. Arrayeinträge haben einen Index. Die 

Zählung beginnt bei 0, wenn nichts anderes definiert wurde. 

• Hashes fassen ebenfalls Skalare zusammen, allerdings werden hier Einzelwerte (Values) nicht über numerische 

Indizes, sondern mit Hilfe zugehöriger Keys (Schlüssel) eindeutig identifiziert und angesprochen. Als Schlüssel 

kann man eine beliebige Zeichenkette benutzen, oder auch alles, was sich in eine Zeichenkette umwandeln lässt. 

Hashes und Arrays lassen sich einander zuweisen, wobei Hashes als Listen von Key/Value-Paaren betrachtet 

werden. Daten verschiedenen Typs lassen sich mittels Referenzen beliebig zu neuen Datenstrukturen kombinieren, 

beispielsweise sind Hashes denkbar, die neben (Referenzen auf) Arrays auch einzelne Skalare enthalten. 

Package-Variablen werden automatisch erstellt, sobald sie das erste Mal verwendet werden. Weitaus häufiger im 

modernen Sprachgebrauch kommen gültigkeitsbeschränkte Variablen zum Einsatz. Diese müssen mittels my 

deklariert werden. undef variable gibt die angegebene Variable wieder frei.



Die grundlegenden Kontrollstrukturen unterscheiden sich kaum von denen in C, Java und JavaScript. 

Bedingte Ausführung 

if funktioniert wie aus C bekannt; unless (), eine Besonderheit von Perl, ist eine Schreibweise für if 

(!()). Eine Case- oder Switch-Anweisung (given when) gibt es erst ab Perl 5.10, vorher musste man 

diese Struktur mit if … elsif … else nachbilden. Jedoch setzt given die Kontextvariable ($_) wie for und when 

wendet smartmatch (~~) darauf an, was dieses Konstrukt ungleich vielfältiger einsetzbar macht als traditionelle 

Case-Befehle. Das optionale default entspricht hier einem else. Die optimierten logischen Operatoren erlauben auch 

eine bedingte Ausführung. Bei or (bzw. ||) wird der zweite Ausdruck ausgeführt, wenn das Ergebnis des ersten kein 

wahrer Wert ist, and (bzw. &&) funktioniert analog. if () {} [elsif () 

{}] [else {}] unless () {} [else {}] 

given () { [when () {}] [default {}] } 

? : ; 

|| ; 

&& ; 

Schleifen 

Wie in C iterieren while und for (in der an C angelehnten Variante), solange die Bedingung wahr ist, until, bis sie 

wahr ist, und foreach iteriert über eine Liste. In Perl 5 sind for und foreach austauschbar. 

[label:] while () 

{} [continue {}] 

[label:] until () 


[label:] for ([]; []; 

[]) 


[label:] for[each] [[my] $element] () 


last verlässt sofort die Schleife, redo wiederholt die derzeitige Iteration, und next springt zum continue-Block, bevor 

es dann mit der nächsten Iteration fortfährt. Diese Befehle können von einem Label-Bezeichner gefolgt sein, der bei 

geschachtelten Strukturen bestimmt, auf welche Schleife sich der Befehl bezieht. 

do {} while ; # Spezialfall: in 

dieser Form 

do {} until ; # mindestens eine 

Ausführung


Nachgestellte Kontrollstrukturen 

Die oberhalb aufgezählten Kontrollstrukturen beziehen sich auf einen Block mit mehreren Anweisungen. Bei 

einzelnen Anweisungen kann man auch die verkürzte, nachgestellte Schreibweise wählen, die auch den 

(englischsprachigen) Lesern das Verständnis durch natürlichsprachige Formulierung erleichtert. 

if ; 

unless ; 

for ; 

while ; 

until ; 

Reguläre Ausdrücke 

Seit seinen Anfängen waren Reguläre Ausdrücke (Regex) ein besonderes Merkmal von Perl, da ähnliche Fähigkeiten 

bis dahin meist nur spezialisierte Sprachen wie Snobol und awk hatten. Durch die große Verbreitung setzte Perl 

einen inoffiziellen Standard, der durch die von Perl unabhängige und auch teilweise abweichende Bibliothek PCRE 

aufgegriffen wurde, die heute von mehreren bedeutenden Sprachen und Projekten verwendet wird. 

Seit Version 5.0 hat Perl seine Regex-Fähigkeiten um viele Funktionen, wie z. B. Rückwärtsreferenzen, erweitert. 

Auch lassen sich Reguläre Ausdrücke in Perl wesentlich direkter – als z. B. in Java – mit dem =~-Operator 

verwenden, da sie Kernbestandteil der Sprache sind und nicht eine zuschaltbare Bibliothek. Der eigentliche Reguläre 

Ausdruck wird mit Schrägstrichen als Begrenzungszeichen notiert. Weil Schrägstriche häufig auch innerhalb 

Regulärer Ausdrücke vorkommen können, dürfen auch viele andere Zeichen zur Begrenzung verwendet werden. Das 

verbessert die Lesbarkeit, weil man so Zeichen wählen kann, die sich vom Inhalt des Regulären Ausdrucks abheben. 

Perl kennt zwei Befehle für Reguläre Ausdrücke, deren Verhalten mit vielen nachgestellten Optionen verändert 

werden kann. 

• Der m-Befehl steht für match, was Übereinstimmung bedeutet. Das m kann weggelassen werden, wenn man die 

Standardbegrenzungszeichen für Reguläre Ausdrücke, nämlich Schrägstriche, verwendet. Der folgende Ausdruck 

durchsucht den Inhalt der Variable $var und liefert einen Array von Zeichenketten, auf die der Suchausdruck 

passt. Mit aktivierter g-Option liefert die Suche im Listenkontext alle Funde, deaktiviert alle erkannten 

Subausdrücke. Im Skalarkontext liefert der Ausdruck einen positiven Wert wenn der Suchausdruck gefunden 

wurde, mit c-Option die Anzahl der Funde. i lässt Groß- und Kleinschreibung ignorieren, o Variablen nur einmal 

interpolieren, m den String als mehrzeilig und s als einzeilig betrachten. Die x-Option ermöglicht es, den 

Suchausdruck der besseren Lesbarkeit wegen über mehrere Zeilen zu verteilen und ihn mit Kommentaren zu 

versehen. 

$var =~ [m]//[g[c]][i][m][o][s][x]; 

• Der s-Befehl steht für substitute, was ersetzen bedeutet. Er ersetzt den Teil des gegebenen Textes, auf den der 

Suchausdruck passt mit dem Ersatzausdruck. 

$var =~ 

s///[e][g][i][m][o][s][x]; 

Nach erfolgreicher Verwendung eines Regulären Ausdruckes stehen folgende Sondervariablen zur Verfügung: 

• $& – der erkannte String 

• $’ – String vor dem erkannten String 

• $' – String nach dem erkannten String 

• $1..$n – Ergebnisse der geklammerten Subausdrücke 

• $+ – der letzte erkannte Subausdruck


• @- – Start-Offsets der Treffer und Subtreffer 

• @+ – dazugehörige End-Offsets 

Der oft in einem Atemzug mit m// und s/// beschriebene Operator tr/// hat mit ihnen nur die Schreibweise gemein. Er 

lehnt sich an den UNIX-Befehl tr an, der dem Ersetzen einzelner Zeichen dient. Synonym kann statt tr auch y 

geschrieben werden. 

$var =~ tr///[c][d][s]; 

Neben diesen beiden kann auch der Befehl split erwähnt werden, der eine Zeichenfolge aufteilt anhand eines 

Trennzeichens, das auch ein Regulärer Ausdruck sein darf. 

Quoting und Interpolation 

Quoting-Operatoren: 

• q – quote nicht interpretierter String 

• qq – quote interpretierter String 

• qw – quote words, eine Liste von mit Whitespace (Leerraum) getrennten Strings 

• qr – quote regex 

• qx – quote auszuführende externe Anwendung 

Alternatives Quoting und Variableninterpolation führen zu besonders gut lesbarem Code. Ein Beispiel zur 

Verdeutlichung: 

• Stringverkettung und Quotingzeichen im Text machen den Code schlecht lesbar. 

$text = 'He\'s my friend ' . $name . ' from ' . $town . '.' 

. ' ' . $name . ' has worked in company "' . $company . '" for ' 

. $years . ' years.'; 

• Interpolation von Variablen im String machen das Ergebnis jetzt erkennbar. Escapes \ stören noch den Textfluss. 

$text = "He's my friend $name from $town. $name has worked in company 

\"$company\" for $years years."; 

• Austausch des Quotingzeichens macht Escapes überflüssig. Der Code ist nun optimal. qq leitet das Quoting von 

Variablen im String ein. Das beliebige Zeichen danach ist das Quotingzeichen für diesen String. 

$text = qq{He's my friend $name from $town. $name has worked in company 

"$company" for $years years.}; 

Perl-Kultur und Spaß 

Gemeinschaft 

Wie auch bei anderen Projekten freier Software gibt es zwischen vielen 

Entwicklern und Benutzern der Sprache besondere soziale Bindungen, und 

es bildete sich eine eigene Kultur daraus. Die Perl-Kultur ist von Offenheit, 

Gastlichkeit und Hilfsbereitschaft, aber auch von Individualismus, 

Spieltrieb und Humor geprägt. Anfangs war sicher Larry Wall hierfür ein 

Vorbild, da er durch andere Projekte wie rn oder patch bereits bei der 

Veröffentlichung von Perl eine prominente Position in 

Logo der Perl Foundation


UNIX-Entwicklerkreisen hatte, doch mittlerweile zählen auch Randal L. Schwartz, Damian Conway, Audrey Tang, 

Brian Ingerson und Adam Kennedy zu den Leitfiguren, die durch ihre Arbeiten innerhalb der „Szene“ große 

Beachtung finden. Im Gegensatz zu kommerziellen Programmiersprachen lassen sich fast alle Aktivitäten auf 

persönliche Motivationen zurückführen. Dementsprechend ist die Perl Foundation eine reine 

Freiwilligen-Organisation, die sich als Angelpunkt einer sich selbst verwaltenden Gemeinschaft versteht und die 

gespendeten Gelder für einflussreiche Projekte und Personen, Organisation von Entwicklerkonferenzen und den 

Betrieb der wichtigsten Perl betreffenden Webseiten verwendet. 

Treffen, Workshops und Konferenzen 

Lokale Benutzergruppen, die meist ein oder zweimal im Monat zu zwanglosen Treffen einladen, bei denen auch 

Vorträge gehalten werden können, nennen sich Perl Mongers und sind in über 200 größeren Städten auf der ganzen 

Welt zu finden. Größer, wesentlich straffer organisiert und meist landesbezogen sind die jährlichen Workshops, von 

denen der gut etablierte Deutsche Perl-Workshop [9] einer der ersten war. Workshops wollen ambitionierte 

Entwickler in einem möglichst erschwinglichen Rahmen lokal zusammenführen. Ein ähnliches Ziel haben die 

größeren Yet Another Perl Conferences (YAPC), die für die Regionen Nordamerika, Europa, Asien und Israel 

abgehalten werden. Am größten, allerdings auch am teuersten ist die von O’Reilly in den USA ausgerichtete The 

Perl Conference (TPF), die mittlerweile Teil der OSCON ist. 

Disziplinen 

Viele Spracheigenschaften von Perl laden dazu ein, Programmcode kreativ zu gestalten. Dies hat zu verschiedenen 

intellektuellen, teils humorvollen, teils skurrilen Wettbewerben und Traditionen um die Programmiersprache Perl 

geführt. 

Golf 

Poesie 

Obfuscation 

Golf ist eine Sportart für Programmierer, bei der das kürzeste Programm (in ASCII-Zeichen), das eine 

gestellte Aufgabe vollständig erfüllt, gewinnt. Da Perl viele, teils trickreiche Kürzel und Abkürzungen 

gängiger Techniken kennt, ist dies eine besonders populäre Disziplin unter Perl-Programmierern. 

Da Perl viele Elemente der englischen Sprache beinhaltet, gibt es regelrechte Wettbewerbe, in welchen die 

besten Beispiele in Perl-Poesie prämiert werden. Neben der freien Form, die lediglich Perl zum Inhalt hat, 

wird hier versucht, Gedichte zu schreiben, die vom Interpreter ohne Warnungen und Fehlermeldungen 

ausgeführt werden [10] . Daneben gibt es auch noch einen Perl-Haiku-Wettbewerb, der dieser japanischen 

Gedichtform gewidmet ist. 

Sehr berühmt und berüchtigt ist auch die Disziplin obfuscation (Verschleierung), für die es auch einen 

jährlichen Wettbewerb (den „Obfuscated Perl Contest“) gibt, der am ehesten mit dem International Obfuscated 

C Code Contest vergleichbar ist, den Larry Wall selbst zweimal gewann. Hier wird danach gestrebt, auf 

ungewöhnliche und kreative Art und Weise die Funktion eines Programms zu verschleiern. Dies ist in Perl 

besonders leicht, da es für fast alles Kürzel gibt, die Sprache selbst sehr dynamisch ist und viele Dinge 

abhängig vom Kontext automatisch geschehen, was auch oft als „Perl-Magie“ bezeichnet wird. Ein Beispiel 

von Mark Jason Dominus, das 2000 beim 5. Annual Obfuscated Perl Contest den zweiten Preis gewann 

(dieses Programm gibt den Text „Just another Perl / Unix hacker“ aus): 

@P=split//,".URRUU\c8R";@d=split//,"\nrekcah xinU / lreP rehtona 

tsuJ";sub p{ 

@p{"r$p","u$p"}=(P,P);pipe"r$p","u$p";++$p;($q*=2)+=$f=!fork;map{$P=$P[$f^ord 

($p{$_})&6];$p{$_}=/


^$P/ix?$P:close$_}keys%p}p;p;p;p;p;map{$p{$_}=~/^[P.]/&& 

close$_}%p;wait until$?;map{/^r/&&}%p;$_=$d[$q];sleep 

rand(2)if/\S/;print 

JAPH 

Perligata 

Eine Art Unterkategorie von obfuscation ist die von Randal L. 

Schwartz öffentlich begonnene Disziplin JAPH. Das sind 

Signaturen, die kleine Perl-Programme enthalten, welche meist 

nur den Namen des Autors oder eine Botschaft auf eine 

möglichst nicht nachvollziehbare Art ausgeben. Die Buchstaben 

JAPH sind die Anfangsbuchstaben von Schwartz’ Signatur Just 

Another Perl Hacker. 

Das Perl-Modul Lingua::Romana::Perligata von Damian 

Conway ist wohl eines der skurrilsten Module schlechthin: Es 

ermöglicht dem Benutzer, Perl komplett in Latein zu schreiben. 

Wie in der lateinischen Sprache ist die Satzstellung (weitgehend) 

irrelevant für die Bedeutung eines Ausdrucks, stattdessen 

werden die Bezüge zwischen einzelnen Wörtern durch ihre 

Flexion hergestellt. Von Variablen bis Referenzen und 

Randal L. Schwartz 

mehrdimensionalen Arrays ist alles in dieser neuen Sprachdefinition vorhanden. Nahezu alle Sonderzeichen 

wurden aus der Sprache entfernt, Variablen gleichen Namens, aber unterschiedlicher Struktur (Beispielsweise 

$next und @next) werden dekliniert, um die entsprechende Variable zu adressieren. Etwas Beispielcode: 

insertum stringo unum tum duo excerpemento da. 

# Entspricht: substr($string,1,2) = $insert; 

clavis hashus nominamentum da. 

Acme 

# Entspricht: @keys = keys %hash; 

Aus ähnlichem Antrieb entstanden „Sprach-Module“ für Klingonisch, Borg oder Leetspeak. Solche Module 

sind ein gutes Beispiel für den Zeitaufwand, den viele Leute Perl widmen; Perl kann man in diesem Sinne 

durchaus als Hobby bezeichnen. 

Brian Ingerson legte mit seinem bekannten Modul namens Acme, das unmittelbar nichts weiter tut, als dem 

Benutzer zu bescheinigen, sein Programm habe den Höchstgrad an Perfektion erreicht, einen Grundstein für 

eine CPAN-Kategorie von Modulen, die keinen produktiven Nutzen haben, sogar oft bewusst kontraproduktiv 

sind oder eine Funktion vorgeben, die unmöglich so erreicht werden kann und eher als Witz zu verstehen ist. 

Dieses Spiel mit skurrilen Ideen umfasst beeindruckende ASCII-Art, Module, die den Quellcode unsichtbar 

machen (Acme::Bleach) oder sonstig humorvoll manipulieren, indem sie ihn zum Beispiel mit typischen 

Sprachfehlern des Präsidenten Bush versehen oder Methoden zufällig löschen, was die Anwesenheit einer 

diebischen Elster simulieren soll.


Mottos und Zitate 

Es gibt viele bekannte Mottos und Zitate, die sich mit Perl selbst oder 

den Möglichkeiten der Sprache beschäftigen; hier einige Kostproben: 

• “Perl: the Swiss Army Chainsaw of Programming Languages.” 

(Perl: Die Schweizer Offiziers-Kettensäge der 

Programmiersprachen. Anspielung auf die Vielseitigkeit von 

Schweizer Offiziersmessern.) 

• “Perl is the only language that looks the same before and after RSA 

encryption.” (Keith Bostic) 

(Perl ist die einzige Sprache, die vor und nach einer 

RSA-Verschlüsselung gleich aussieht.) 

• “Only perl can parse Perl.” (Larry Wall) 

(Nur perl kann Perl parsen.) 

Perl-Programmierer sehen Kamele jeder Art als 

Maskottchen. Die London Perl Mongers haben 

sogar eines aus dem Londoner Zoo adoptiert. 

• “… we often joke that a camel is a horse designed by a committee, but if you think about it, the camel is pretty 

well adapted for life in the desert. The camel has evolved to be relatively self-sufficient. On the other hand, the 

camel has not evolved to smell good. Neither has Perl.” (Larry Wall: über das Kamel als Perl-Maskottchen) 

(… wir witzeln oft, dass ein Kamel ein Pferd ist, das von einem Komitee entworfen wurde. Aber wenn man 

darüber nachdenkt, ist das Kamel ziemlich gut an das Leben in der Wüste angepasst. Das Kamel hat sich dahin 

entwickelt, autark zu sein. Andererseits hat es sich nicht dazu entwickelt, gut zu riechen. Perl auch nicht.) 

• “The very fact that it’s possible to write messy programs in Perl is also what makes it possible to write programs 

that are cleaner in Perl than they could ever be in a language that attempts to enforce cleanliness” (Larry Wall: 

Linux World, 1999) 

(Genau die Tatsache, dass es möglich ist, unsaubere Programme in Perl zu schreiben, ermöglicht es, Programme 

zu schreiben, die sauberer sind, als in Sprachen, die versuchen, Sauberkeit zu erzwingen.) 

• “Perl: Write once – never understand again” 

(Perl: Einmal schreiben – nie wieder verstehen. Eine Anspielung auf das “Write once – run everywhere”-Mantra 

z. B. von Java) 

Weitere Informationen 

Wettbewerbe 

Im Jahr 2004 erreichte Perl beim 7. Wettbewerb des International Conference on Functional Programming Contest 

eine Platzierung in der Lightning Division. 

Literatur 

Für Programmier-Anfänger 

• Brigitte Jellinek, Jutta Hämmerle-Uhl: Easy Perl. Markt und Technik, München 2001, ISBN 3-8272-6153-8 

(Zielrichtung Web/CGI) 

• Jürgen Schröter: "Grundwissen Perl" Oldenbourg Verlag, München 2007, ISBN 978-3-486-58074-7 

(Alltags-Programmieraufgaben) 

Für Perl-Einsteiger 

• Randal L. Schwartz, Tom Phoenix: Einführung in Perl. O’Reilly Verlag, ISBN 3-89721-434-2 (das Lamabuch, 

basiert auf Einsteigerkurs) 

• Larry Wall u. a.: Programmieren mit Perl. O’Reilly Verlag, ISBN 3-89721-144-0 (das Kamelbuch, Handbuch, 

das die ganze Sprache umfasst)


• Johan Vromans: Perl – kurz und gut. O’Reilly Verlag, ISBN 3-89721-247-1 (Kurzreferenz) 

Für Fortgeschrittene 

• Randal L. Schwartz, Tom Phoenix: Einführung in Perl-Objekte, Referenzen & Module. O’Reilly Verlag 2003, 

ISBN 3-89721-149-1 (das Alpaka-Buch, Fortsetzung des Lamabuches) 

• Joseph N. Hall, Randal L. Schwartz: Effective Perl Programming. Addison-Wesley Professional 1997, ISBN 

0-201-41975-0 (Stärken von Perl effektiv nutzen) 

• Christiansen, Torkington: Perl Kochbuch. O’Reilly Verlag 2004, ISBN 3-89721-366-4 (Problemlösungen mit 

Codebeispielen) 

• Mark Jason Dominus: Higher-Order Perl. Morgan Kaufmann, 2005, ISBN 1-55860-701-3 (Funktionale 

Programmierung in Perl) 

Weblinks 

• Links zum Thema Perl [11] im Open Directory Project (deutsch) 

• perl.org/ – Offizielle, sehr umfangreiche Website von Perl [12] (allgemeine Informationen; englisch) 

• Deutsches Perl-Tutorial für Einsteiger [13] 

• Downloadmöglichkeit: ActivePerl, Perl-Distribution für Windows mit eigenem Paketformat bei der Binärmodule 

vorkompiliert sind und aus einem vom CPAN getrennten Archiv entstammen [14] 

• Strawberry Perl 5.10 [15] – Perl-Distribution mit Compilersuite für Windows. Soll die problemlose Installation 

von binären CPAN-Modulen erlauben, für MS Windows 2000 bis MS Windows Vista 

• $foo – Perl-Magazin [16] , deutschsprachig 

Referenzen 

[1] http:/ / www. perl. org/ 

[2] manpage von Perl 1.0 in der Perl-Timeline (http:/ / history. perl. org/ PerlTimeline. html#1980s) (englisch) auf perl.org 

[3] http:/ / www. bibleserver. com/ go. php?lang=de& bible=EU& ref=Mt13%2C46 

[4] Der erste Teil der offiziellen Perl-FAQ (englisch) (http:/ / perldoc. perl. org/ perlfaq1. 

html#What's-the-difference-between-"perl"-and-"Perl"?) 

[5] Larry Walls Rede auf der OSCON 2000 als perl.com-Artikel (http:/ / www. perl. com/ pub/ a/ 2000/ 10/ 23/ soto2000. html) (englisch) 

[6] Perl6 Community Development Server: Perl6::Perl5::Differences -- Differences between Perl 5 and Perl 6 (http:/ / feather. perl6. nl/ syn/ 

Differences. html) (englisch), Stand: 5. September 2006 

[7] http:/ / search. cpan. org/ ~sisyphus/ Inline-0. 45/ Inline. pod 

[8] http:/ / www. gnu. org/ software/ octave/ 

[9] Deutscher Perl-Workshop (http:/ / www. perl-workshop. de) 

[10] zum Beispiel perlmonks.org – Perl-Poetry-Kategorie (engl.) (http:/ / www. perlmonks. org/ index. pl?node=Perl Poetry) 

[11] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ Perl/ 

[12] http:/ / www. perl. org 

[13] http:/ / perl-seiten. privat. t-online. de/ 

[14] http:/ / www. activestate. com/ Products/ activeperl/ 

[15] http:/ / strawberryperl. com/ 

[16] http:/ / www. foo-magazin. de/

PHP 123 

PHP 

PHP 

serverseitig interpretierte Skriptsprache 

Basisdaten 

Paradigmen: imperativ, 

objektorientiert 


Designer: Rasmus Lerdorf 

Entwickler: The PHP Group 


5.3.2 [1] (4. März 2010) 

Typisierung: schwach, dynamisch 

Einflüsse: Perl, C, C++, Java 


Lizenz: PHP-Lizenz 

www.php.net [2] 

PHP (rekursives Akronym für „PHP: Hypertext Preprocessor“, Backronym aus „Personal Home Page Tools“) ist 

eine Skriptsprache mit einer an C angelehnten Syntax, die hauptsächlich zur Erstellung dynamischer Webseiten oder 

Webanwendungen verwendet wird. [3] PHP wird als freie Software unter der PHP-Lizenz verbreitet. 

PHP zeichnet sich besonders durch die leichte Erlernbarkeit, die breite Datenbankunterstützung und 

Internet-Protokolleinbindung sowie die Verfügbarkeit zahlreicher, zusätzlicher Funktionsbibliotheken aus. 

Beispielsweise existieren Programmbibliotheken, um Bilder und Grafiken zur Einbindung in Webseiten dynamisch 

zu generieren. 

Geschichte 

PHP wurde 1995 von Rasmus Lerdorf entwickelt. Der Begriff stand damals noch für Personal Home Page Tools und 

war ursprünglich als Ersatz für eine Sammlung von Perl-Skripten gedacht, die Lerdorf zur Protokollierung der 

Zugriffe auf seinen Online-Lebenslauf geschrieben hatte. [4] Bald schuf Lerdorf eine umfangreichere Version in der 

Programmiersprache C, in der PHP bis heute entwickelt wird. Das schließlich veröffentlichte PHP/FI (FI stand für 

Form Interpreter) war Perl sehr ähnlich, wenn auch eingeschränkter.

PHP 124 

PHP3 

PHP 3 wurde von Andi Gutmans und Zeev Suraski neu geschrieben, da das inzwischen erschienene PHP/FI 2 ihrer 

Meinung nach für E-Commerce unzureichend war. Lerdorf kooperierte nun mit Gutmans und Suraski, und so wurde 

die Entwicklung von PHP/FI eingestellt. Diese Version brachte die Verbreitung der Web-Skriptsprache PHP 

bedeutend voran. 

PHP4 

Das von Gutmans und Suraski gegründete Unternehmen Zend Technologies Ltd. entwickelte in der Folge die Zend 

Engine 1, die den Kern der PHP-4-Standardimplementierung bildet. Mit PHP 4 wurden die 

Ausführungsgeschwindigkeit komplexer Applikationen und die Sicherheit bei Verwendung globaler Variablen 

verbessert. Eingeführt wurden die Unterstützung für viele weitere Webserver, das Sessionmanagement, die 

Ausgabepufferung sowie eine Anzahl neuer Sprachkonstrukte. 

Da das World Wide Web Ende der 1990er Jahre stark wuchs, bestand großer Bedarf an Skriptsprachen, mit denen 

sich dynamische Webseiten realisieren lassen. PHP wurde mit der Zeit für die Webentwicklung populärer als der 

vorherige De-facto-Standard Perl, weil es durch seine Spezialisierung als einfacher erlernbar gilt. 

PHP5 

Im Sommer 2004 wurde mit Version 5.0 eine weitere Entwicklungsstufe veröffentlicht. Wesentlicher Unterschied 

zum Vorgänger ist die Zend Engine II, die vor allem ein verbessertes Objektmodell nutzt, somit objektorientierte 

Anwendungen effizienter ausführt und Sprachkonstrukte wie Überladung ermöglicht. Dazu kommen Exceptions, 

Reflections, die Integration der SQLite Datenbank sowie Erweiterungen bei XML- und DOM-Handhabung. 

Wichtige Versionen 

Haupt- 

version 

Legende: Ältere Version; nicht mehr unterstützt Ältere Version; noch unterstützt Aktuelle Version Zukünftige Version 

Version Veröffentlichung Wichtigste Änderungen 

1.x 1.0 8. Juni 1995 Offiziell „Personal Home Page Tools (PHP Tools)“ genannt. Das ist die erste Verwendung des Begriffes 

„PHP“. 

2.x 2.0 16. April 1996 Von den Entwicklern als das „schnellste und einfachste Tool“ zum Erstellen von dynamischen Webseiten 

bezeichnet. 

3.x 3.0 6. Juni 1998 Die Entwicklung wird nicht mehr nur von einer Person vorangetrieben. Zeev Suraski und Andi Gutmans 

schreiben die Codebasis für diese Version vollständig neu.

PHP 125 

4.x 4.0 22. Mai 2000 

Einfache objektorientierte Programmierung hinzugefügt. Hinzufügen einer fortgeschrittenen zweistufigen 

Parser-/Ausführungsmaschine, Zend Engine genannt. [5] 

4.0.6 23. Juni 2001 Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 4.0; fünf Aktualisierungen 

4.1 10. Dezember 

2001 

erschienen zuvor: 4.0.1 bis 4.0.5. 

Einführung von „Superglobals“ ($_GET, $_POST, $_SESSION, etc.). 

4.1.2 12. März 2002 Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 4.1; zuvor erschien die 

Aktualisierung 4.1.1. 

4.2 22. April 2002 Standardmäßige Deaktivierung von register_globals. Daten, die über ein Netzwerk empfangen werden, 

4.2.3 6. September 

2002 

4.3 27. Dezember 

2002 

werden nicht direkt in den globalen Namensraum eingefügt. Damit werden potentielle Sicherheitslücken in 

der Anwendung verhindert. 

Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 4.2; zwei Aktualisierungen 

erschienen zuvor: 4.2.1 und 4.2.2. 

Einführung von CLI als Zusatz zu CGI. 

4.3.11 31. März 2005 Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 4.3; zehn Aktualisierungen 

4.4 11. November 

2005 


Hinzufügen von Man-Seiten für phpize und php-config-Skripten. 

4.4.9 7. August 2008 Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 4.4; acht Aktualisierungen 


5.x 5.0 13. Juli 2004 Zend Engine II mit neuem Objektmodell, das private Methoden und Attribute und Überladung erlaubt. 

5.0.5 5. September 

2005 


2005 

Exceptions hinzugefügt, Reflections API, MySQLi (MySQL verbessert, objektorientiert und auf aktuelle 

MySQL-Versionen zugeschnitten), SQLite integriert, SimpleXML (einfacher XML-Parser, Update und 

Insert von Kindelementen möglich), DOM-Unterstützung. 

Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 5.0; vier Aktualisierungen 


Leistungsverbesserungen durch die Einführung von Compilervariablen. Datenbankabstraktionsschicht 

hinzugefügt (PDO). 

5.1.6 24. August 2006 Letzte Sicherheits- und Stabilitätsaktualisierung des Entwicklungszweigs 5.1; fünf Aktualisierungen 


2006 


Schnellere und effizientere Speicherverwaltung, Filter-Erweiterung hinzugefügt (Filtern und Verifizieren 

von Benutzereingaben), JSON hinzugefügt (Serialisierung von PHP-Variablen, nützlich im Zusammenspiel 

mit Ajax), ZIP (Auslesen und Erstellen von ZIP-Archiven) hinzugefügt, objektorientierte 

Datums-Erweiterung (DateTime und DateTimeZone) hinzugefügt. 

5.2.13 25. Februar 2010 Sicherheits- und Stabilitätsaktualisierung; zwölf Aktualisierungen erschienen zuvor: 5.2.1 bis 5.2.12. 

5.3 30. Juni 2009 Unterstützung von Namensräumen (Namespaces); verbesserter XML-Support durch Nutzung von 

XMLReader und XMLWriter; SOAP-Unterstützung, Late Static Binding, Jump label (begrenzt auf goto), 

Closure, Native PHP-Archive (Phar). 

5.3.2 4. März 2010 Sicherheits- und Stabilitätsaktualisierung; eine Aktualisierung erschien zuvor: 5.3.1. 

6.x 6.0 Unicode-Support; Entfernung der ereg-Erweiterung, „register_globals“, „magic_quotes“ und „safe_mode“; 

Entfernung von mime_magic und Restrukturierung von fileinfo() für besseren MIME-Support. 

In der Regel wird jedem Entwicklungszweig ein Maintainer zugeordnet, der von den Hauptentwicklern bestimmt 

wird. Der Maintainer ist nun für die Verwaltung und die Pflege des ihm zugeordneten Entwicklungszweiges 

zuständig. Aktuell ist ausschließlich den Zweigen für PHP 5.2.x und PHP 5.3.x ein Maintainer zugeordnet.

PHP 126 

Ausblick 

Zurzeit wird die Version 6.0 entwickelt. Bisher bekannte Änderungen sind zum einen die Entfernung von „Altlasten“ 

wie Register Globals, Magic Quotes und dem Safe Mode, zum Anderen die Unterstützung von Unicode. Neuerungen 

wie Namensräume, „late static binding“ [6] und ein neuer, nativer MySQL-Treiber waren eigentlich für die Version 6 

geplant, wurden aber schon in PHP 5.3 eingeführt. 

Allgemein 

Darstellung der Funktionsweise von PHP 

PHP ist ein System, das PHP-Code serverseitig verarbeitet. Das bedeutet, dass der Quelltext nicht an den 

Webbrowser übermittelt wird, sondern an einen Interpreter auf dem Webserver. Erst die Ausgabe des 

PHP-Interpreters wird an den Browser geschickt. In den meisten Fällen ist das ein HTML-Dokument, wobei es mit 

PHP aber auch möglich ist, andere Dateitypen, wie Bilder oder PDF-Dateien, zu generieren. 

Um eine PHP-Datei im Rahmen einer Webanwendung ausführen zu können, benötigt man ein System, das mit den 

in der Datei enthaltenen Anweisungen umgehen kann. Aus diesem Grund wird durch eine Schnittstelle, wie ISAPI 

oder CGI, der Interpreter von einem Server-Daemon oder Server-Dienst, wie Apache oder IIS, ausgeführt. Die 

Kombination von Linux/Windows als Betriebssystem, Apache als Webserver, MySQL als Datenbanksystem und 

PHP wird LAMP (für Linux) oder WAMP (für Windows) genannt. Fertige LAMP- und WAMP-Pakete, die das 

einzelne Laden und Konfigurieren von Paketen aus dem Internet unnötig machen, werden etwa im Projekt XAMPP 

entwickelt. Hier gibt es Versionen für Linux, Solaris, Windows und Mac OS X. 

Die serverseitige Ausführung bietet einige Vorteile. Beim Client (Browser) sind keine Besonderheiten erforderlich, 

so können keine Inkompatibilitäten auftreten wie bei den verschiedenen Ausprägungen von JavaScript. Der 

PHP-Quelltext bleibt auf dem Server und nur die generierten Daten sind für den Besucher sichtbar. Gleiches gilt für 

andere Ressourcen wie Datenbanken, die daher keine direkte Verbindung zum Client benötigen. 

Ein Nachteil ist, dass jede Aktion des Benutzers erst beim erneuten Aufruf der Seite erfasst wird. Da PHP 

normalerweise in einer Webserver-Umgebung läuft, unterliegt es auch dem zustandslosen HTTP. Jede PHP-Seite 

belastet den Webserver durch den Interpreter, zudem arbeitet der Interpreter den Quelltext bei jedem Aufruf erneut 

ab. Das mindert die Reaktionsgeschwindigkeit des Servers und erhöht die Last. Um dem entgegenzuwirken, stehen 

verschiedene Bytecode-Caches zur Verfügung, die eine zur Ausführung vorbereitete Version des Programmes 

zwischenspeichern und somit den Zugriff auf diese Datei beim nächsten Aufruf beschleunigen (siehe auch Abschnitt 

Ausführungsgeschwindigkeit). 

Mit PHP lassen sich auch kommandozeilenorientierte Skripte schreiben, die vom Internet unabhängig sind. Die 

GTK-Erweiterung stellt sogar eine Programmierschnittstelle für eine grafische Oberfläche zur Verfügung, für die 

weder ein Webserver noch ein Browser benötigt werden. Die ersten Versionen der Schnittstellen zur grafischen 

Oberfläche und zu anderen Betriebssystemfunktionen waren spärlich und wurden kaum verwendet. Die aktuell 

entwickelte PHP-GTK-Version 2 strebt hingegen eine Abdeckung der GTK-API von 95% an. [7] Gegenwärtig wird 

PHP jedoch vor allem auf Webservern genutzt.

PHP 127 

Code-Beispiel 

Einfaches PHP-Skript (gibt „Hallo Welt!“ aus): 

 

echo "Hallo Welt!"; 

Das Skript in HTML integriert (gibt ebenfalls „Hallo Welt!“ auf der Webseite aus): 

 

 

 

Hallo-Welt-Beispiel 

 

 

 

 

 

echo "Hallo Welt!"; 

Anmerkung: Der PHP-Interpreter interpretiert den Code zwischen , der übrige Code (üblicherweise 

HTML) wird unverändert an den Client zurückgegeben. 

Kritik 

Kritiker führen eine Reihe von Unzulänglichkeiten in PHP an. So sei die Sprache zeitweise ungesteuert gewachsen, 

es wurden viele ähnlich arbeitende Funktionen oft unterschiedlich benannt und die Reihenfolge der 

Funktionsparameter stimme bei Funktionen mit ähnlichem Zweck teils nicht überein. Zudem seien trotz vorhandener 

Objektorientierung die meisten Standardbibliotheken noch prozedural angelegt. Threading fehle in PHP völlig, und 

einige PHP-Module sind nicht threadsicher. 

PHP besitze zudem keinen eigenen Bytecode-Cache, was ohne entsprechende Erweiterung bei jedem Aufruf einer 

Datei ein komplettes Parsen notwendig macht. 

Weiterentwicklung 

PHP wird kontinuierlich weiterentwickelt und befindet sich weiterhin in einem Wandel. So wurde etwa die 

Einstellung der Entwicklung von PHP 4 bekannt gegeben. 

Seit der Version 5 unterstützt PHP durch Kapselung der Daten, Destruktoren und Ausnahmebehandlung per 

Exceptions verbesserte und erweiterte Möglichkeiten der objektorientierten Programmierung. Auch 

Objekt-Variablen sind in PHP 5 wie bei den meisten Programmiersprachen nur noch Referenzen auf Objekte und 

nicht wie in PHP 4 die Objekte selbst. Ebenso wurde dem oft bemängelten uneinheitlichen Zugriff auf verschiedene 

Datenbanken in der Version 5.1 mit der objektorientierten Datenbankabstraktionsebene PDO entgegengewirkt. Ab 

der Version 5.3 werden von PHP zudem Namensräume unterstützt. [8] 

In der Version 6 werden endgültig Probleme verursachende Komponenten wie Magic Quotes [9] , der Safe Mode [10] 

sowie Register Globals [11] , die schon länger standardmäßig deaktiviert sind, entfernt. Außerdem werden sämtliche 

veralteten (deprecated) Funktionen sowie Aliase von Funktionen entfernt. Auch wird der Standardzeichensatz von 

ISO 8859-1 auf Unicode geändert. [12] Damit werden vor allem interne Probleme mit Sprachkonstrukten bei der

PHP 128 

Verarbeitung von Unicode gelöst. Bis PHP 6 gibt es nur wenige Funktionen, bei denen ein Zeichensatz für die 

Verarbeitung von Zeichenketten angegeben werden kann, sowie Funktionen zur Konvertierung von und nach UTF-8. 

Häufige Problemquellen 

Programmierungsspezifisch 

Die schwache Typisierung von PHP ist Teil des Konzepts, aber auch eine häufige Fehlerquelle. Ein Fehler tritt etwa 

auf, wenn numerische Werte mit Zeichenketten verglichen werden sollen, wobei es durch die implizite 

Typumwandlung zu unerwarteten Ergebnissen kommen kann, sofern nicht der Operator für typsichere Vergleiche 

verwendet wurde. Auch die unübliche Vereinigung des Array-Konzepts mit dem Dictionary-Konzept sorgt bei 

Programmierern, die mit anderen Programmiersprachen vertraut sind, teils für Fehler. Zudem ist es in PHP nicht 

möglich, eine Variablendeklaration zu erzwingen – Variablen werden vielmehr stets automatisch angelegt, sobald 

sie erstmals verwendet werden. Diese Bequemlichkeit hat zur Folge, dass etwa Tippfehler im Variablennamen zu 

schwer auffindbaren Programmfehlern führen können. Dieses Verhalten kann jedoch durch andere Einstellung der 

Fehlerberichterstattung abgefangen werden. [13] 

Webanwendungsspezifisch 

Im Zusammenhang mit globalen Variablen und unsicheren Serverkonfigurationen können Daten in ein Skript 

eingeschleust werden, indem etwa URL-Parameter gesetzt werden. Um diese Art von Manipulation zu verhindern, 

empfiehlt das PHP-Handbuch, die Option register_globals=off in der PHP-Konfiguration zu setzen. Seit 

PHP 4.2 ist das standardmäßig der Fall; in PHP 5.3 wurde die Option als veraltet eingestuft und soll in PHP 6.0 

entfernt werden. [14] Generell sollte jede Variable vor der ersten Verwendung initialisiert werden. [15] 

Weiterhin bestehen Gefahren über SQL-Injections oder Cross-Site Scripting-Attacken, die jedoch nicht 

PHP-spezifisch sind, sondern für alle Webanwendungen gelten. Sie lassen sich beseitigen, indem alle Daten, die das 

[15] [16] 

Programm von außen über HTTP oder andere Protokolle empfängt, sorgfältig geprüft und gefiltert werden. 

Schutzsysteme für PHP-Installationen 

Suhosin [17] ist ein von Stefan Esser, einem ehemaligen Mitglied des „PHP Security Response Team“ [18] und 

Mitentwickler von PHP, entwickeltes Schutzsystem für PHP-Installationen. Es wurde entworfen, um den Server und 

die Benutzer vor bekannten und unbekannten Fehlern in PHP-Anwendungen und im PHP-Kern zu schützen. 

Ausführungsgeschwindigkeit 

Setzt man PHP als CGI-Programm ein, so kann sich das negativ auf die Ausführungsgeschwindigkeit auswirken, 

denn für jede HTTP-Anfrage startet der Webserver hier eine neue Instanz des PHP-Interpreters. Um den Start der 

Interpreter-Instanzen zu sparen, setzt man PHP üblicherweise als Servermodul, also als Teil der Webserver-Prozesse, 

oder über FastCGI ein. 

Laut dem Computer Language Shootout [19] wie auch bei dessen Windows-Gegenstück Win32 Computer Language 

Shootout [20] liegt PHP bei Standardproblemen in Bezug auf Laufzeit und Ressourcenverbrauch in den meisten 

Leistungstests leicht bis deutlich hinter anderen verbreiteten Skriptsprachen wie Python oder Perl.

PHP 129 

Steigerung der Ausführungsgeschwindigkeit 

OP-Code-Caching 

Mit der Zend-Engine wird der Code zunächst zu einem (plattformunabhängigen) Bytecode (Zend-OP-Code) 

übersetzt, aus dem zur Ausführung noch Maschinencode erzeugt werden muss. Durch Anlegen eines Caches für 

diesen Bytecode kann durch die Vermeidung redundanter Generierung von OP-Code gespart werden. PHP besitzt 

selbst keinen Bytecode-Cache, was dazu führt, dass ein Skript bei jedem Aufruf neu übersetzt werden muss. Um 

dem entgegenzuwirken, gibt es einige Erweiterungen, die diese Funktionalität nachrüsten, wie beispielsweise den 

eAccelerator, den Alternative PHP Cache sowie den kommerziellen Zend Optimizer. Besonders bei umfangreichen 

Skripten kann so eine deutliche Steigerung der Ausführungsgeschwindigkeit erreicht werden. 

Kompilierung 

Mit HipHop existiert eine freie Software zum Übersetzen von PHP-Code in optimierten C++-Code, der kompiliert 

werden kann, was nach Herstellerangaben dort die Leistung im Schnitt auf etwa das Doppelte steigert. [21] 

Verbreitete PHP-Applikationen 

Eine Auswahl verschiedener, weit verbreiteter Applikationen, die in PHP geschrieben wurden: 

• Invision Power Board, phpBB, Simple Machines Forum, vBulletin und WoltLab Burning Board – Foren-Software 

• phpMyAdmin, phpPgAdmin – grafische Benutzeroberflächen zur Verwaltung von MySQL- bzw. 

PostgreSQL-Datenbanken 

• TYPO3, Joomla!, Xoops, Drupal – Content-Management-Systeme (CMS) 

• WordPress, Serendipity – Software für das Erstellen von Weblogs 

• Horde – Application Framework für Webanwendungen 

• SugarCRM – CRM (Customer Relationship Management) 

• MediaWiki – Wiki-Software 

• osCommerce, Magento – E-Commerce-Applikationen 

Lizenz und Bezug 

PHP 3 wurde unter der GNU General Public License (GPL) vertrieben. Seit Version 4 wird PHP unter der PHP 

License vertrieben, da der neue Parser, die Zend Engine, vom Hersteller Zend unter einer nicht GPL-kompatiblen 

Lizenz veröffentlicht wird. Die PHP-Lizenz ist eine Softwarelizenz, die die freie Verwendung und Veränderung der 

Quelltexte erlaubt. Die Software kann somit kostenlos aus dem Internet geladen werden; daneben ist PHP auch im 

Lieferumfang einiger Betriebssysteme (so bei Linux-Distributionen oder Mac OS X) enthalten. 

Literatur 

• Matthias Kannengiesser: PHP 5 / MySQL 5. Studienausgabe. Franzis, Poing 2007. ISBN 3-7723-6919-7 

• George Schlossnagle: Professionelle PHP 5-Programmierung. Addison-Wesley, München 2005. ISBN 

3-8273-2198-0 

• Jörg Krause: PHP 5, Grundlagen und Profiwissen. 2. Auflage. Hanser, München 2005. ISBN 3-446-40334-5 

• Jens Ferner: PHP 5 Referenz. Data Becker, Düsseldorf 2004. ISBN 3-8158-2369-2 

• R. Samar, C. Stocker (Hrsg.), A. Gildemeister: PHP de Luxe – PHP5 Edition. mitp, Bonn 2004. ISBN 

3-8266-1482-8 

• Martin Goldmann, Markus Schraudolph: PHP 5 – Die Neuerungen. Galileo Press, Bonn 2004. ISBN 

3-89842-490-1 

• Carsten Möhrke: Besser PHP programmieren. Galileo Press, Bonn 2004. ISBN 3-89842-381-6 

• Christian Wenz, Tobias Hauser: PHP 5 Kompendium. Markt und Technik, Düsseldorf 2005. ISBN 3-8272-6292-5

PHP 130 

• Stefan Priebsch: Enterprise PHP Tools. entwickler.press, Frankfurt M 2006. ISBN 3-935042-93-0 

• Stephan Schmidt: PHP Design Patterns. 1. Auflage. O’Reilly, Köln 2006. ISBN 3-89721-442-3 

• Christopher Kunz, Peter Prochaska, Stefan Esser: PHP-Sicherheit. 2. Auflage. dpunkt-Verlag, Heidelberg 2007. 

ISBN 3-89864-450-2 

• Damir Enseleit: SELFPHP – Das PHP Kochbuch. Franzis, Poing 2006. ISBN 3-7723-7107-8 

• Thomas Theis: Einstieg in PHP 5 & MySQL 5. 4. Auflage. Galileo press, Bonn 2006. ISBN 3-89842-854-0 

• Tobias Wassermann: Sichere Webanwendungen mit PHP. 1. Auflage. mitp, Bonn 2007. ISBN 3-8266-1754-1 

Weblinks 

• Offizielle Website [2] (englisch) 

• PHP-Handbuch in deutsch [22] 

Referenzen 

[1] PHP 5 ChangeLog Version 5.3.2. (http:/ / www. php. net/ ChangeLog-5. php#5. 3. 2) The PHP Group, 4. März 2010, abgerufen am 12. März 

2010. 

[2] http:/ / www. php. net/ 

[3] Rasmus Lerdorf: „PHP's design goal from the very beginning is very simple. To solve the common web problem. That's it.“ (http:/ / www. 

advogato. org/ article/ 470. html#3) 

[4] Ankündigung von Rasmus Lerdorf zu PHP 1.0 in der Newsgroup comp.infosystems.www.authoring.cgi (http:/ / groups. google. ch/ group/ 

comp. infosystems. www. authoring. cgi/ msg/ cc7d43454d64d133?oe=UTF-8& output=gplain) 

[5] PHP: PHP 4 ChangeLog (http:/ / www. php. net/ ChangeLog-4. php). The PHP Group (3. Januar 2008). Abgerufen am 22. Februar 2008. 

[6] PHP-Handbuch: Late Static Bindings (http:/ / de. php. net/ lsb) 

[7] http:/ / gtk. php. net (Englisch), abgerufen am 17. Juni 2007 

[8] PHP-Handbuch: Namespaces (http:/ / de. php. net/ manual/ de/ language. namespaces. php) 

[9] PHP-Handbuch: Magic quotes (http:/ / de. php. net/ manual/ en/ security. magicquotes. php) 

[10] PHP-Handbuch: Safe mode (http:/ / de. php. net/ manual/ en/ features. safe-mode. php) 

[11] PHP-Handbuch: Register Globals (http:/ / de. php. net/ manual/ en/ security. globals. php) 

[12] PHP-Conference 2005: Präsentation von Andrei Zmievski (http:/ / www. gravitonic. com/ downloads/ talks/ intlphpcon2005/ php_unicode. 

pdf) (PDF) 

[13] PHP-Handbuch: Option error_reporting (http:/ / de. php. net/ manual/ de/ ref. errorfunc. php#ini. error-reporting) 

[14] PHP: Beschreibung der php.ini-Direktiven des Sprachkerns. (http:/ / de3. php. net/ manual/ de/ ini. core. php#ini. register-globals) In: PHP 

Manual. Abgerufen am 4. Juli 2009. 

[15] PHP: Verwendung von Register Globals. (http:/ / de3. php. net/ manual/ de/ security. globals. php) In: PHP Manual. Abgerufen am 4. Juli 

2009. 

[16] PHP: Vom Nutzer übermittelte Daten. (http:/ / de3. php. net/ manual/ de/ security. variables. php) In: PHP Manual. Abgerufen am 4. Juli 

2009. 

[17] Hauptseite des Suhosin-Projekts (http:/ / www. hardened-php. net/ suhosin/ index. html) 

[18] News auf Golem.de: „PHP-Sicherheit: Stefan Esser wirft hin“ (http:/ / www. golem. de/ showhigh2. php?file=/ 0612/ 49448. html) 

[19] The Computer Language Benchmarks Game (http:/ / shootout. alioth. debian. org) 

[20] The Great Win32 Computer Language Shootout (http:/ / dada. perl. it/ shootout/ ) 

[21] Alexander Neumann: Facebook will PHP beschleunigen. (http:/ / www. heise. de/ developer/ meldung/ 

Facebook-will-PHP-beschleunigen-920684. html) In: heise Developer. heise Zeitschriften Verlag, 3. Februar 2010, abgerufen am 23. Februar 

2010. 

[22] http:/ / de. php. net/ manual/ de/


Profan (Programmiersprache) 

XProfan ist eine basicähnliche Programmiersprache, die direkt für die ereignisorientierte Programmierung 

graphischer Oberflächen geschaffen wurde. 

Entwicklungsgeschichte, Versionen 

Profan² ist eine 1990 von Roland G. Hülsmann erfundene Programmiersprache, welche seit Version 8 zu XProfan 

(extended Profan²) herangewachsen ist. 

XProfan gilt als eine auch für Anfänger einfache Programmiersprache; sie enthält Elemente der Sprachen Basic und 

Pascal. Der Fokus liegt hierbei auf den 32 bit Windows-Umgebungen, es existieren aber auch funktional 

eingeschränkte Profan²-Versionen für Linux und MS-DOS. 

XProfan stellt die Mittel zur Verfügung, einfach und schnell eine Windows-Anwendung zu entwerfen. Dabei sind 

viele Sprachkonstrukte zur Dialoggestaltung und Datenverarbeitung bereits fest integriert, der Entwickler kann sich 

um das „was“ kümmern, statt sich mit dem „wie“ herumschlagen zu müssen. Neben diesen grundlegenden 

Funktionen bietet Profan² Schnittstellen z. B. zu Datenbanken (dBASE ist fest integriert, ODBC kann genutzt 

werden) oder dem Internet (FTP, SMTP). 

Durch die Nutzung der Windows-API oder DLLs lässt sich der Funktionsumfang beinahe beliebig erweitern. Neben 

den zahlreichen von der Community bereitgestellten Libraries können auch viele, für andere Sprachen entworfene 

Bibliotheken genutzt werden. 

Bis Version 7.0 war Profan² eine rein prozedurale Programmiersprache, mit Version 8.0 – die erstmals unter dem 

Namen XProfan vertrieben wurde – hielt die objektorientierte Programmierung Einzug. Diese Richtung wurde mit 

der im Frühjahr 2005 erschienenen Version 9 nochmals erweitert. Neben der rein prozeduralen Entwicklung ist nun 

auch eine rein objektorientierte oder eine Mischform möglich. 

Die aktuelle Version trägt die Versionsnummer 11.2a und zeichnet sich vor allem durch die neu integrierte 

OpenGL-Schnittstelle aus. 

Mit seinen vielfältigen Möglichkeiten bietet Profan² eine gute Plattform zum Einstieg in die Programmierung von 

Windows-Anwendungen, bietet aber gleichzeitig erfahrenen Entwicklern genug Spielraum (z. B. im Bereich 

Messagehandling, über Rückruffunktionen (callback function) oder mit dem Debugger). 

Profan² wurde mit Borland Delphi (bis Version 9.1 in Delphi 2, Version 10 in Delphi 5, ab Version 11 in Turbo 

Delphi 2006) entwickelt. Es besitzt sowohl Interpreter als auch Compiler und Linker. Kompilierte Programme sind 

erheblich schneller als der Interpreter, können jedoch mit anderen Sprachen wie C in Bezug auf die 

Abarbeitungsgeschwindigkeit nicht konkurrieren. 

Seit April 2007 gibt es von David Strutz (dem Betreiber der XProfan.Com) eine an die Syntax von Profan² 

angelehnte kleine Sonderversion des Profan² namens jProfan. jProfan ist kein offizielles „Profan²“ oder „XProfan“, 

bietet aber den Entwicklern ebenso eine basicähnliche Programmiersprache dessen Programme in DOM-fähigen 

Browsern wie z. B. Firefox oder Internet-Explorer ablaufen und somit betriebssystemunabhängig sind. Dies 

ermöglicht eine extra hierfür (auch von David Strutz) in JavaScript programmierte virtuelle API namens jUI welche 

Funktionen zur Bereitstellung einer grafischen Oberfläche bietet auf die jProfan aufbaut. Das Besondere an jProfan 

ist – neben der Betriebssystemunabhängigkeit – das jeder einfach auf der Website dank der in jProfan entwickelten 

jProfan-IDE kostenlos jProfan-Programme entwickeln kann und diese jedem zur Verfügung stellen kann. Besonders 

für Schulen oder Programmieranfänger ist diese Variante interessant, da grundsätzlich nichts installiert werden muss 

und ein leichterer Einstieg in höhere Versionen des Profan² oder XProfan gegeben ist. Bislang existiert noch keine 

offizielle Version von jProfan.


Am 10. Oktober 2007 lief die Subskriptions-Aktion für Version 11 an. Neuerungen sind vor allem ein dynamisches 

Speichermanagement, dynamische Arrays, native Unterstützung für Trayicons, Imagelist und Treeviews, 

Unterstützung zum Speichern von JPEG und PNG, Subclassing sowie der Wegfall programmtechnischer Grenzen. 

Aktuell ist die XProfan Version 11.2a, die mehrere Bugfixes und Erweiterungen im Vergleich zur Version 11 

erfahren hat. 

Seit April 2009 gibt es von Frank Abbing einen eigenständigen externen Inline Assembler "XPIA". XPIA bietet eine 

Erweiterung des XProfan-Befehlssatzes unter Zuhilfenahme schnellerer Assembler-Funktionen und 

Assembler-Bibliotheken. Die Syntax der einbettbaren Assemblercodes ist annähernd zu 100% MASM32 kompatibel 

und unterstützt auch Macros und High-Level-Code. XPIA kommt ab Version 4 ohne installiertes MASM32-Paket 

und externen Precompiler aus und enthält weitere nützliche Tools. 

Profan² ist für folgende Betriebssysteme erhältlich: 

Bis Version 6.6: 

• Windows 3.x 

• MS-DOS 

• Linux 

• Atari Portfolio 

• OS/2 

Ab Version 7 und XProfan: 

• 95, 98, ME, NT, 2000 XP, Vista, 7 

Funktionsweise 

Der Quelltext kann direkt interpretiert und/oder kompiliert werden. Die entstehenden Kompilate können vom 

Kompiler mit einer beliebigen Runtime zur einer ausführbaren Win32-Anwendung gelinkt werden. Das 

XProfan-Standardruntime kann bearbeitet werden und es stellt einen beliebig erweiterbaren Grundsprachschatz 

sicher. 

Besonderheiten/Features 

• Eine Besonderheit stellt die Profan² SE-Version dar. Diese eingeschränkte Version ist für Schulen und 

Bildungseinrichtungen kostenfrei erhältlich und soll z. B. im Informatikunterricht oder in Arbeitsgruppen 

Verwendung finden. 

• XProfan bietet die Möglichkeit zur prozeduralen und zur objektorientierten Programmierung. 

• Kompilate können von der Runtime auch dann noch ausgeführt werden wenn die Runtimes bereits mit einem 

eigenen Kompilat verlinkt sind. Dies bietet auch Anfängern die Möglichkeit, die eigenen Anwendungen modular 

aufzubauen und sich das Plug-in-Prinzip zu Nutze zu machen. 

• XProfan-Programme werden nicht zu nativem Maschinencode, sondern nur zu einem kompakteren Zwischencode 

kompiliert, der zur Laufzeit vom Runtime interpretiert wird, wodurch sich ein Geschwindigkeitsnachteil ergibt. 

• Units (ähnlich wie statische Bibliotheken aus C++) herstellen und/oder nutzen. Diese Units sind bereits kompiliert 

und können eine Erweiterung des Grundsprachschatzes darstellen. 

• OpenGL ist im Sprachschatz inbegriffen. 

• InlineAssembler dank kostenloser Zusatzprogramme wie z. B. PreKompiler möglich. 

• Win32-XProfanprogramme können unter Linux mit WINE ausgeführt werden.


„Hallo Welt“ in XProfan 

Print "Hallo Welt" 

WaitInput 

oder einfach nur: 

messagebox("Hallo Welt","Info",0) 

Weblinks 

• Offizielle Seite [1] 

• XProfan Community [2] 

• Online Dokumentation [3] 

• Debugger für XProfan [4] 

Referenzen 

[1] http:/ / xprofan. de/ start. htm 

[2] http:/ / xprofan. com/ start. htm 

[3] http:/ / xprofan. com/ hilfe 

[4] http:/ / prfdebug. de 

PureBasic 

PureBasic 

Entwickler: Fantaisie Software 

Aktuelle Version: Windows: 4.41 (31. Januar 2010) 

Linux: 4.41 (31. Januar 2010) 

Mac OS X: 4.41 (31. Januar 2010) 

Amiga OS: 4.00 (10. Dezember 2006) 

Betriebssystem: Windows, Linux, Mac OS X, Amiga OS 

Kategorie: Prozedurale Programmiersprache 

Lizenz: Proprietär 

Deutschsprachig: Ja 

www.purebasic.de [1] 

PureBasic ist eine von Frédéric Laboureur (Fantaisie Software, Frankreich) entwickelte prozedurale 

Programmiersprache für Windows, Linux, Mac OS X und Amiga OS, die kommerziell vertrieben wird.

PureBasic 134 

Allgemeines 

PureBasic ist eine auf BASIC basierende Programmiersprache. Die Schlüsselfeatures sind Portierbarkeit 

(gegenwärtig werden Windows, Linux, Mac OS X vollständig sowie Amiga OS teilweise unterstützt), die Erstellung 

sehr schneller und hochoptimierter ausführbarer Programme und die einfach zu erlernende BASIC-Syntax. Damit ist 

PureBasic für Anfänger ebenso wie Experten geeignet. Trotz der anfängerfreundlichen Syntax machen die 

Möglichkeiten fortgeschrittener Features, wie z. B. Zeiger, Strukturen, Prozeduren, dynamisch verknüpfte Listen, 

PureBasic zu einer vielseitigen Programmiersprache. Auch die Verwendung von Inline-Assembler für zeitkritische 

Code-Abschnitte ist möglich. 

Features 

• Umfangreiche Standard-Bibliothek. Zum Beispiel für GUI-Gadgets, Grafik, Sound, Netzwerk, Datenbank, 

Kompression, Kryptografie, u.v.a 

• Erweiterbarer Funktionsumfang durch selbsterstellte Bibliotheken. 

• Entwicklungsumgebung mit integriertem 32-Bit- bzw. 64-Bit-Compiler, der auch Inline-Assembler unterstützt. 

• Die integrierte Entwicklungsumgebung enthält einen visuellen Designer in den Versionen für Linux und 

Windows. 

• Quelltext ist portierbar zwischen Windows, Linux, Mac OS X und teilweise Amiga OS. 

• Erstellte Anwendungen benötigen keine externen DLLs oder andere externe Ressourcen. 

• Unterstützung von Prozeduren zur strukturierten Programmierung mit lokalen und globalen Variablen 

• Voller Zugriff auf die Programmierschnittstelle (API) des jeweils verwendeten Betriebssystems. 

• Einfache Realisierung von 2D- und 3D-Spielen durch integrierte Bibliotheken möglich (DirectX, SDL, OGRE). 

Geschichte 

Der PureBasic-Erfinder Frédéric Laboureur schrieb Ende der 1990er Jahre für die Amiga-Version von Blitz Basic 

viele zusätzliche Befehle in 68000 Assembler (Assemblersprache für die Motorola 68000er-Familie). Da Blitz Basic 

für den Amiga einige Jahre zuvor offiziell eingestellt wurde, entwickelte er zusammen mit Roger Beausoleil den 

ersten Compiler, der die für Blitz Basic geschriebenen Befehle nutzte. Dieser Compiler unterstützte schon damals 

verschiedene Prozessorarchitekturen (zunächst Code-Generierung für PowerPC sowie 680x0). Später wurde er auf 

die heute unterstützten Systeme Windows, Linux und Mac OS X portiert. Das Ergebnis war PureBasic. Zunächst 

wollte Laboureur seine Sprache Phoenix taufen. Jedoch verwarf er diese Idee, da er befürchtete, dass Anwender 

diesen Namen ohne das Anhängsel BASIC in Suchmaschinen nicht finden würden. Anschließend wollte er es 

PowerBasic nennen. Doch dieser Name war bereits für eine andere Programmiersprache vergeben. Letzten Endes 

entschied sich Laboureur für PureBasic. Durch pure (deutsch klar, rein) möchte er ausdrücken, dass PureBasic leicht 

zu verstehen und einfach anzuwenden ist. Die erste Version von PureBasic, die nicht den Beta-Status trug, erschien 

am 17. Dezember 2000. Seit dem 4. November 2007 ist die Version 4.10 für Windows, Linux und Mac OS X 

verfügbar, mit der es erstmals möglich ist, unabhängig vom Betriebssystem auf den gesamten Befehlssatz von 

PureBasic zurückzugreifen, was die Portierbarkeit der Quelltexte vereinfacht. Aktuelle Version ist 4.41 vom 31. 

Januar 2010. 

Lizenz 

PureBasic wird pro Anwender lizenziert. Das bedeutet, dass ein Benutzer mit dem Kauf einer Lizenz PureBasic auf 

jedem beliebigen Computer installieren darf. Eine Purebasic Lizenz gilt für alle unterstützten Plattformen, sie ist also 

nicht an eine Entwicklungsplattform gebunden. Allerdings darf die Lizenz nicht zwischen mehreren Personen geteilt 

werden. Die Lizenz von PureBasic ist somit proprietär. Ausnahme bilden lediglich die Standardbibliotheken der 

Version für Amiga OS, die als Open Source frei verfügbar sind. Eine Besonderheit der Lizenz ist das darin 

enthaltene Recht auf lebenslang kostenlose Updates auf neue Versionen.

PureBasic 135 

Vertriebswege 

Vertrieben wird PureBasic in der Regel online über die offizielle Homepage [2] oder über den deutschen 

PureBasic-Support auf www.purearea.net [3] . 

Hallo-Welt-Programm 

Der folgende Quelltext stellt ein einfaches PureBasic-Programm dar, das die Meldung "Hallo Welt!" in einem 

Benachrichtigungsfenster ausgibt: 

MessageRequester("Nachricht", "Hallo Welt!") 

Die Ausgabe unter Windows: 

Dieser Code gibt "Hallo Welt!" in einer Console aus: 

OpenConsole() 

Print("Hallo Welt!") 

Input() ;wartet auf das Drücken von Enter 

Ausgabe: 

Entwicklungsumgebung 

Die integrierte Entwicklungsumgebung 

von PureBasic setzt sich neben vielen 

nützlichen Werkzeugen aus einem 

Texteditor, Compiler, Debugger sowie 

einen visuellen Designer zusammen. 

Syntaxhervorhebung, Code-Faltung, 

Zeilennummerierung und mehr wird 

durch die Verwendung der 

Editor-Komponente Scintilla 

unterstützt. Außerdem lässt sich die 

Entwicklungsumgebung individuell an die eigenen Bedürfnisse anpassen. So kann man zum Beispiel eigene Farben 

zur Syntaxhervorhebung definieren oder Werkzeuge von Drittanbietern in die Entwicklungsumgebung integrieren.

PureBasic 136 

PureBasic-Applikationen 

PureBasic Editor PureBasic Visual Designer 

Folgend eine Liste mit Spielen und Programmen, die mit PureBasic erstellt wurden: 

Spiele 

• Dune 2077 [4] , Echtzeit-Strategiespiel 

• Hostile Skies [5] , 2D-Shooter mit Hubschraubern 

• Krakout unlimited 2 [6] , Remake des C64-Klassikers Krakout 

• Lady's Garden [7] , vergleichbar mit Pac-Man 

• Breaker [8] , ein Remake von Arkanoid (kommerziell) 

• Brickliner [9] , ein Mix aus Puzzle und Tetris (kommerziell) 

• Legend - Hand of God [10] , Rollenspiel (kommerziell) 

• Restricted Area [11] , Rollenspiel (kommerziell) 

Anwendungen 

• PureVisionXP [12] , alternativer visueller Designer für PureBasic (kommerziell) 

• SoccerTrainer [13] , eine Verwaltungssoftware für Fußball-Trainer (kommerziell) 

• PureWare Business-Software [14] , eine komplette Business-Anwendung mit Touch-Kassenfunktion (teilweise 

Freeware, Premium-Edition kommerziell) 

Weblinks 

• Offizielle Homepage mit offiziellem Forum [15] (deutsch, englisch und französisch) 

• PureArea.net - PureBasic Support- und Bestellseite [3] (deutsch und englisch) 

• Purebasic-Lounge (Forum) [16] Alternative Deutsche PureBasic-Community 

• PureBoard [17] (deutsches Purebasic-Forum)

PureBasic 137 

Referenzen 

[1] http:/ / www. purebasic. de 

[2] http:/ / www. purebasic. com 

[3] http:/ / www. purearea. net 

[4] http:/ / www. computerbild. de/ download/ Dune-2077-2240006. html 

[5] http:/ / www. reelmediaproductions. com/ hs 

[6] http:/ / www. krakout. com/ 

[7] http:/ / www. reelmediaproductions. com/ lady 

[8] http:/ / www. wegroup. org/ games/ arkanoid-games/ breaker. html 

[9] http:/ / www. wegroup. org/ games/ puzzle-logic/ brickliner. html 

[10] http:/ / www. legend-game. com/ 

[11] http:/ / www. restrictedarea. de/ 

[12] http:/ / www. reelmediaproductions. com/ purevision 

[13] http:/ / www. soccer-trainer. com/ 

[14] http:/ / www. pureware. at/ 

[15] http:/ / www. purebasic. com/ german/ 

[16] http:/ / purebasic-lounge. com/ 

[17] http:/ / www. purebasic. fr/ german/ 

Python (Programmiersprache) 

Python 

Basisdaten 



Entwickler: Python Software Foundation 

Aktuelle Version: 3.1.2 (21. März 2010) 

2.6.5 (19. März 2010) 

Typisierung: stark, dynamisch („Duck Typing“) 

wichtige Implementierungen: CPython, Jython, IronPython, PyPy 

Einflüsse: ABC, Algol 60, Modula-3, Icon, C, Perl, LISP, Smalltalk, TCL, Haskell 

Beeinflusste: Ruby, Boo, Groovy 

Lizenz: 

Python License [1] 

www.python.org [2] 

Python [ˈpaɪθn̩] ist eine universelle höhere Programmiersprache. [3] 

Ihre Entwurfsphilosophie betont 

Programmlesbarkeit. [4] Ihr Gebrauch von Einrückung zur Blockbegrenzung ist ungewöhnlich unter populären 

Programmiersprachen. 

Python unterstützt mehrere Programmierparadigmen. So werden objektorientierte, aspektorientierte und funktionale 

Programmierung unterstützt. Wie andere dynamische Sprachen, wird Python oft als Skriptsprache genutzt. 

Die Sprache hat ein offenes, gemeinschaftsbasiertes Entwicklungsmodell, gestützt durch die gemeinnützige Python 

Software Foundation, die de facto die Definition der Sprache in CPython, der Referenzumsetzung pflegt.


Entwicklungsgeschichte 

Die Sprache wurde Anfang der 1990er Jahre von Guido van Rossum am Centrum Wiskunde & Informatica (Zentrum 

für Mathematik und Informatik) in Amsterdam als Nachfolger für die Programmier-Lehrsprache ABC entwickelt und 

war ursprünglich für das verteilte Betriebssystem Amoeba gedacht. Alle bisherigen Implementierungen der Sprache 

(siehe auch Jython oder Stackless Python) übersetzen den Text eines Python-Programms transparent in einen 

Zwischencode, der dann von einem Interpreter ausgeführt wird. 

Namensherkunft 

Der Name geht nicht etwa (wie das Logo vermuten ließe) auf die gleichnamige Schlangengattung (Pythons) zurück, 

sondern bezog sich ursprünglich auf die englische Komikertruppe Monty Python. In der Dokumentation finden sich 

daher auch einige Anspielungen auf Sketche aus dem Flying Circus. [5] Trotzdem etablierte sich die Assoziation zur 

Schlange, was sich unter anderem in der Programmiersprache Cobra [6] sowie dem Python-Toolkit „Boa“ [7] äußert. 

Ziele 

Python wurde mit dem Ziel entworfen, möglichst einfach und übersichtlich zu sein. Dies soll durch zwei 

Maßnahmen erreicht werden: Zum einen kommt die Sprache mit relativ wenigen Schlüsselwörtern aus [8] , zum 

anderen ist die Syntax reduziert und auf Übersichtlichkeit optimiert. Dies führt dazu, dass Python eine Sprache ist, in 

der schnell und einfach programmiert werden kann. Sie ist daher besonders dort geeignet, wo Übersichtlichkeit und 

Lesbarkeit des Codes eine herausragende Rolle spielen – zum Beispiel in der Teamarbeit, bei Beschäftigung mit 

dem Quelltext nach längeren Pausen oder bei Programmieranfängern. 

Durch die Möglichkeit, auch Programme anderer Sprachen als Modul einzubetten, werden viele Nischen in der 

Programmierung abgedeckt. Bei Bedarf lassen sich so beispielsweise zeitkritische Teile durch maschinennah in C 

programmierte Routinen ersetzen, oder Python kann als Skriptsprache eines anderen Programms dienen (Beispiele: 

OpenOffice.org, Blender, Cinema 4D, Maya, PyMOL, SPSS und GIMP). 

Python ist eine Multiparadigmensprache. Das heißt, Python zwingt den Programmierer nicht zu einem einzigen 

bestimmten Programmierparadigma, sondern erlaubt es, das für die jeweilige Aufgabe am besten geeignete 

Paradigma zu wählen. Objektorientierte und strukturierte Programmierung werden vollständig unterstützt, weiterhin 

gibt es Spracheigenschaften für funktionale und aspektorientierte Programmierung. 

Die Datentypen werden dynamisch verwaltet; eine statische Typprüfung (wie z. B. bei C++) gibt es nicht. Die 

Freigabe nicht mehr benutzter Speicherbereiche erfolgt durch automatische Speicherbereinigung (garbage 

collection). Unicode-Unterstützung existiert seit Version 2.0. 

In der Versionsreihe 2.6 können sich Entwickler mit dem Kommandozeilenparameter „-3“ alle Konstrukte in ihrem 

Code anzeigen lassen, die es ab Python 3.0 nicht mehr gibt. [9] 

Datentypen und Strukturen 

Python besitzt eine größere Anzahl von grundlegenden Datentypen. Neben der herkömmlichen Ganzzahl- und 

Gleitkommaarithmetik unterstützt es transparent auch beliebig große Ganzzahlen und komplexe Zahlen. 

Es verfügt über die übliche Ausstattung an Zeichenkettenoperationen. Zeichenketten sind in Python allerdings 

unveränderliche Objekte (wie auch in Java). Damit führen Operationen, die das Ändern einer Zeichenkette 

bewerkstelligen sollen – wie z. B. das Ersetzen von Zeichen – dazu, dass stattdessen eine neue Zeichenkette 

zurückgegeben wird. 

In Python ist alles ein Objekt; Klassen, Typen, Methoden, Module etc. Der Datentyp ist an das Objekt (den Wert) 

gebunden und nicht an eine Variable, d. h. Datentypen werden dynamisch vergeben, so wie bei Smalltalk oder LISP 

– und nicht wie bei Java. Alle Parameter werden per Referenz übergeben. Durch die Bindungsregeln, die den


Zusammenhang zwischen Objekten und Variablen festlegen, scheint es bei unveränderlichen Objekten aber so als 

würden diese als Wert übergeben. 

Trotz der dynamischen Typverwaltung enthält Python eine gewisse Typprüfung. Diese ist strenger als bei Perl, aber 

weniger strikt als etwa bei Objective CAML. Implizite Umwandlungen nach dem Duck-Typing-Prinzip sind unter 

anderem für numerische Typen definiert, so dass man beispielsweise eine komplexe Zahl mit einer langen Ganzzahl 

ohne explizite Typumwandlung multiplizieren kann. Anders als bei Perl gibt es allerdings keine implizite 

Umwandlung zwischen Zahlen und Zeichenketten; in Operationen für Zeichenketten kann also anstelle einer 

Zeichenkette nicht direkt eine Zahl verwendet werden. Der Operator == überprüft zwei Objekte auf 

(Wert-)Gleichheit. Der Operator is überprüft die tatsächliche Identität zweier Objekte. [10] 

Sammeltypen 

Python besitzt mehrere Sammeltypen, darunter Listen, Tupel, Mengen (Sets) und Wörterbücher (Dictionaries). 

Listen, Tupel und Zeichenketten sind Folgen (Sequenzen, Arrays) und kennen fast alle die gleichen Methoden: Über 

die Zeichen einer Kette kann man ebenso iterieren wie über die Elemente einer Liste. Listen sind erweiterbare Felder 

(Arrays), wohingegen Tupel eine feste Länge haben und unveränderlich sind. 

Der Zweck solcher Unveränderlichkeit hängt mit den Wörterbüchern zusammen, ein Datentyp, der auch als 

assoziatives Array bezeichnet wird. Um auch unter den Bedingungen der Übergabe per Referenz die 

Datenkonsistenz zu sichern, müssen die Schlüssel eines Wörterbuches vom Typ „unveränderlich“ sein. Die ins 

Wörterbuch eingetragenen Werte können dagegen von beliebigem Typ sein. 

Sets sind Mengen von Objekten und in CPython ab Version 2.4 im Standardsprachumfang enthalten. Diese 

Datenstruktur kann beliebige (paarweise unterschiedliche) Objekte aufnehmen und stellt Mengenoperationen wie 

beispielsweise Durchschnitt, Differenz und Vereinigung zur Verfügung. 

Objektsystem 

Das Typsystem von Python ist auf das Klassensystem abgestimmt. Obwohl die eingebauten Datentypen genau 

genommen keine Klassen sind, können Klassen von einem Typ erben. So kann man die Eigenschaften von 

Zeichenketten oder Wörterbüchern erweitern – auch von Ganzzahlen. Python unterstützt daneben 

Mehrfachvererbung. 

Die Sprache unterstützt direkt den Umgang mit Typen und Klassen. Typen können ausgelesen (ermittelt) und 

verglichen werden und verhalten sich wie Objekte – in Wirklichkeit sind die Typen (wie in Smalltalk) selbst ein 

Objekt. Die Attribute eines Objektes können als Wörterbuch extrahiert werden. 

Syntax 

Eines der Entwurfsziele für Python war die gute Lesbarkeit des Quellcodes. Die Anweisungen benutzen häufig 

englische Schlüsselwörter, wo andere Sprachen Symbole einsetzen. Darüber hinaus besitzt Python weniger 

syntaktische Konstruktionen als viele andere strukturierte Sprachen wie C, Perl oder Pascal: 

• zwei Schleifenformen 

• for zur Iteration über die Elemente einer Sequenz 

• while zur Wiederholung einer Schleife, solange ein logischer Ausdruck wahr ist. 

• Verzweigungen 

• if … elif … else für Verzweigungen 

Beim letzten Punkt bieten andere Programmiersprachen zusätzlich switch und/oder goto. Diese wurden zugunsten 

der Lesbarkeit in Python weggelassen und müssen durch if-Konstrukte oder andere Verzweigungsmöglichkeiten 

(Slices, Wörterbücher) abgebildet werden.


Strukturierung durch Einrücken 

Python benutzt wie Miranda und Haskell Einrückungen als Strukturierungselement. Diese Idee wurde erstmals von 

Peter J. Landin vorgeschlagen und von ihm off-side rule („Abseitsregel“) genannt. In den meisten anderen 

Programmiersprachen werden Blöcke durch Klammern oder Schlüsselwörter markiert, während verschieden große 

Leerräume außerhalb von Zeichenketten keine spezielle Semantik tragen. Bei diesen Sprachen ist die Einrückung zur 

optischen Hervorhebung eines Blockes zwar erlaubt und in der Regel auch erwünscht, aber nicht vorgeschrieben. Für 

Programmierneulinge wird der Zwang zu lesbarem Stil aber als Vorteil gesehen. 

Hierzu ein kurzes Beispiel: Hier sind Funktionen in C und in Python, die das gleiche ausführen – die Fakultät einer 

Ganzzahl berechnen. 

Fakultätsfunktion in C (ohne Einrückung): 

int fakultaet(int x) {if (x > 1) return x * fakultaet(x - 1); else 

return 1;} 

Fakultätsfunktion in C (mit Einrückung): 

int fakultaet(int x) 

{ 

} 

if (x > 1) 

else 

return x * fakultaet(x - 1); 

return 1; 

Jetzt die gleiche Funktion in Python: 

def fakultaet(x): 

if x > 1: 

else: 

return x * fakultaet(x - 1) 

return 1 

Die Fakultätsfunktion ohne Einrückung in Python: 

def fakultaet(x): return x * fakultaet(x - 1) if x > 1 else 1 

Es ist jedoch darauf zu achten, die Einrückungen im gesamten Programmtext gleich zu gestalten. Die gemischte 

Verwendung von Leerzeichen und Tabulatorzeichen kann zu Problemen führen, da für den Pythoninterpreter ein 

Tabulator äquivalent zu acht Leerzeichen behandelt wird. Je nach Konfiguration des Editors können Tabulatoren 

optisch mit weniger als acht Leerzeichen dargestellt werden, was zu Syntaxfehlern oder ungewollter 

Programmstrukturierung führen kann. Als vorbeugende Maßnahme kann man den Editor Tabulatoren durch eine 

feste Anzahl von Leerzeichen ersetzen lassen. Die Python-Distribution enthält in der Standardbibliothek das Modul 

tabnanny, welches die Vermischung von Tabulatoren und Leerzeichen erkennen und beheben hilft.


Funktionales Programmieren 

Ausdrucksstarke syntaktische Elemente zur funktionalen Programmierung vereinfachen das Arbeiten mit Listen und 

anderen Sammeltypen. Eine solche Vereinfachung ist die Listennotation, die aus der funktionalen 

Programmiersprache Haskell stammt; hier bei der Berechnung der ersten fünf Zweierpotenzen: 

zahlen = [1, 2, 3, 4, 5] 

zweierpotenzen = [2 ** n for n in zahlen] 

Weil in Python Funktionen als Argumente auftreten dürfen, kann man auch ausgeklügeltere Konstruktionen 

ausdrücken, wie den Continuation-passing style. 

Pythons Schlüsselwort lambda könnte manche Anhänger der funktionalen Programmierung fehlleiten. Solche 

lambda-Blöcke in Python können nur Ausdrücke enthalten, aber keine Anweisungen. Damit sind sie nicht der 

allgemeinste Weg, um eine Funktion zurückzugeben. Die übliche Vorgehensweise ist stattdessen, den Namen einer 

lokalen Funktion zurückzugeben. Das folgende Beispiel zeigt dies anhand einer einfachen Funktion nach den Ideen 

von Haskell Brooks Curry: 

def add_and_print_maker(x): 

def temp(y): 

print("{} + {} = {}".format(x, y, x + y)) 

return temp 

Damit ist auch Currying auf einfache Art möglich, um generische Funktionsobjekte auf problemspezifische 

herunterzubrechen. Hier ein einfaches Beispiel: 

def curry(func, knownargument): 

return lambda unknownargument: func(unknownargument, knownargument) 

Wird die curry-Funktion aufgerufen, erwartet diese eine Funktion mit zwei notwendigen Parametern sowie die 

Parameterbelegung für den zweiten Parameter dieser Funktion. Der Rückgabewert von curry ist eine Funktion, 

die dasselbe tut wie func aber nur noch einen Parameter benötigt. 

Anonyme Namensräume (sog. Closures) sind mit den o.g. Mechanismen in Python ebenfalls einfach möglich. Ein 

simples Beispiel für einen Stack, intern durch eine Liste repräsentiert: 

def stack(): 

l = [] 

def pop(): return l.pop() 

def push(element): l.append(element) 

def isempty(): return len(l) == 0 

return pop, push, isempty 

POP, PUSH, ISEMPTY = stack() 

Auf diese Weise erhält man die drei Funktionsobjekte POP, PUSH, ISEMPTY, um den Stack zu modifizieren 

bzw. auf enthaltene Elemente zu prüfen, ohne l direkt modifizieren zu können.


Ausnahmebehandlung 

Python nutzt ausgiebig die Ausnahmebehandlung (engl. exception handling) als ein Mittel, um Fehlerbedingungen 

zu testen. Dies ist so weit in Python integriert, dass es sogar möglich ist, Syntaxfehler abzufangen und zur Laufzeit 

zu behandeln. 

Ausnahmen haben einige Vorteile gegenüber anderen beim Programmieren üblichen Verfahren der 

Fehlerbehandlung (wie z.B. Fehler-Rückgabewerte und globale Statusvariablen). Sie sind Thread-sicher und können 

leicht bis in die höchste Programmebene weitergegeben oder an einer beliebigen anderen Ebene der 

Funktionsaufruffolge behandelt werden. Der korrekte Einsatz von Ausnahmebehandlungen beim Zugriff auf 

dynamische Ressourcen erleichtert es zudem, bestimmte auf Race Conditions basierende Sicherheitslücken zu 

vermeiden, die entstehen können, wenn Zugriffe auf bereits veralteten Statusabfragen basieren. 

Der Python-Ansatz legt den Einsatz von Ausnahmen nahe, wann immer eine Fehlerbedingung entstehen könnte. 

Nützlich ist dieses Prinzip beispielsweise bei der Konstruktion robuster Eingabeaufforderungen: 

while True: 

try: 

num = raw_input("Eine Zahl eingeben: ") 

num = int(num) 

break 

except ValueError: 

print("Eine _Zahl_, bitte!") 

Dieser Code wird den Benutzer so lange nach einer Nummer fragen, bis dieser eine Zeichenfolge eingibt, die sich 

per int() in eine Ganzzahl konvertieren lässt. Durch die Ausnahmebehandlung wird hier vermieden, dass eine 

Fehleingabe zu einem Laufzeitfehler führt, der das Programm zur Beendigung zwingt. 

Ebenso kann auch das hier nicht berücksichtigte Interrupt-Signal (SIGINT, häufig Strg+C) mittels 

Ausnahmebehandlung in Python abgefangen und behandelt werden (except KeyboardInterrupt: …). 

Standardbibliothek 

Python verfügt über eine große Standardbibliothek, wodurch es sich für viele Anwendungen gut eignet. Sie ist eine 

der größten Stärken von Python. Das meiste davon ist plattformunabhängig, so dass auch größere 

Python-Programme oft auf Unix, Windows, Mac OS X und anderen Plattformen ohne Änderung laufen. Die Module 

der Standardbibliothek können mit in C oder Python selbst geschriebenen Modulen ergänzt werden. 

Die Standardbibliothek ist besonders auf Internet-Anwendungen zugeschnitten, mit der Unterstützung einer großen 

Anzahl von Standardformaten und -Protokollen (wie MIME und HTTP). Module zur Schaffung grafischer 

Schnittstellen, zur Verbindung mit relationalen Datenbanken und zur Manipulation regulärer Ausdrücke sind 

ebenfalls enthalten. 

Mit Hilfe des mitgelieferten Moduls Tkinter kann in Python (wie in Perl und Tcl) schnell eine grafische Oberfläche 

(GUI) mit Tk erzeugt werden. Es gibt darüber hinaus eine Vielzahl von weiteren Wrappern von anderen Anbietern. 

Sie stellen Anbindungen (engl. language bindings) zu GUI-Bibliotheken anderer Programmiersprachen wie z. B. 

PyGTK, PyQt, PyKDE, wxPython, PyObjC und PyFLTK zur Verfügung.


Beispiel 

Als nicht triviales Beispiel sei hier der Quicksort-Algorithmus angegeben: 

def quicksort(liste): 

if len(liste) = pivotelement] 

return quicksort(links) + [pivotelement] + quicksort(rechts) 

Hier ermöglicht insbesondere die Listennotation für die Variablen links und rechts eine kompakte Darstellung. Zum 

Vergleich eine imperative Formulierung dieser zwei Zeilen: 

... 

nehmen 

links, rechts = [], [] # Leere Listen links und rechts 

pivotelement = liste.pop() # Das letzte Element aus der Liste 

for element in liste: # Die verkürzte Liste durchlaufen 

anhängen 

... 

if element < pivotelement: 

else: 

Interaktive Benutzung 

links.append(element) # wenn < dann an linke Liste anhängen 

rechts.append(element) # wenn nicht < (also >=) dann an rechte Liste 

So wie LISP, Ruby, Groovy – und Perl im Debugger – unterstützt der Python-Interpreter auch einen interaktiven 

Modus, in dem Ausdrücke am Terminal eingegeben und die Ergebnisse sofort betrachtet werden können. Das ist 

nicht nur für Neulinge, die die Sprache lernen, angenehm, sondern auch für erfahrene Programmierer: 

Code-Stückchen können interaktiv ausgiebig getestet werden, bevor man sie in ein geeignetes Programm aufnimmt. 

Darüber hinaus steht mit PyShell ein Kommandozeileninterpreter für verschiedene unixoide 

Computer-Betriebssysteme zur Verfügung, der neben klassischen Unix-Shellkommandos auch direkte Eingaben in 

Python-Form verarbeiten kann. 

Implementierungen 

• CPython 

• PyPy 

• Parrot 

• Jython (für die Java Virtual Machine) 

• IronPython (für .NET) 

• Stackless Python


Entwicklungsumgebung 

Es existieren einige spezielle Entwicklungsumgebungen für Python, beispielsweise Eric Python IDE. Des Weiteren 

existieren Plugins für größere IDEs wie Eclipse und Netbeans. Texteditoren für Programmierer wie Vim und Emacs 

lassen sich gegebenenfalls auch für Python anpassen. 

Verbreitung und Einsatz 

• Python ist für die meisten gängigen Betriebssysteme frei erhältlich und eine der drei Sprachen, die häufig in einer 

LAMP-Umgebung eingesetzt werden. Um Python in den Webserver einzubinden, wurde mod python entwickelt, 

das die Ausführung im Vergleich zu CGI wesentlich beschleunigt und Daten persistent speichern kann. Als 

Alternative stellt WSGI eine universelle Schnittstelle zwischen Webserver und Python(-Framework) zur 

Verfügung. 

• Eine Reihe von Web-Application-Frameworks nutzt Python, darunter Django, Pylons, TurboGears, web2py 

oder Zope. 

• Es gibt einen in Java implementierten Python-Interpreter namens Jython, mit dem die Bibliothek des Java 

Runtime Environments für Python verfügbar gemacht wird. 

• Ebenso existiert eine Python-Implementierung (IronPython) für die .NET- bzw. Mono-Plattform. 

• Um Python als Skriptsprache für Programme in C++ zu nutzen, setzt sich vermehrt die Boost.Python-Bibliothek 

durch. 

• Ein Python-Parser für Parrot und ein in Python geschriebener Interpreter für Python, PyPy, welcher von der EU 

gefördert wurde, sind ebenfalls in Entwicklung. 

• Es gibt einen Python-Interpreter für das Symbian-Betriebssystem, so dass Python auf verschiedenen 

Mobiltelefonen verfügbar ist. 

• Es existiert ein Python-Interpreter für Mikrocontroller namens PyMite. [11] 

• Python in der Version 2.5.1 ist Bestandteil von AmigaOS 4.0. 

• Python wird im Rahmen des Projektes 100-Dollar-Laptop als Standardsprache für die Benutzeroberfläche 

verwendet. Da der 100-Dollar-Laptop für die Schulausbildung von Kindern konzipiert ist, soll bei Benutzung der 

dafür gestalteten grafischen Benutzeroberfläche „Sugar“ auf Knopfdruck der gerade laufende Python-Quellcode 

angezeigt werden. [12] Damit soll Kindern die Möglichkeit gegeben werden, die dahinterliegende 

Informationstechnologie real zu erleben und nach Belieben „hinter die Kulissen“ zu schauen. 

Kritik 

• Bei der Definition (aber nicht beim Aufruf) von Methoden muss der Parameter self, der dem Objekt entspricht, 

dessen Methode aufgerufen wird, explizit angegeben werden. Dies wird oft als unelegant und „nicht 

objektorientiert“ empfunden. [13] Es ist aber nötig, um bestimmte wichtige Konstrukte zu ermöglichen. [14] 

• Die Art, wie Python zwischen so genannten „veränderlichen“ (mutable) und „unveränderlichen“ (immutable) 

Datentypen unterscheidet, kann für Neulinge zu überraschendem Verhalten führen. [15] 

• In einer Methodendefinition erfordert der Aufruf der Basisklassenversion derselben Methode die explizite Angabe 

der Klasse und Instanz. Dies wird als Verletzung des DRY (Don't Repeat Yourself)-Prinzips gesehen und 

behindert Umbenennungen (dies wurde in Python 3.0 behoben [16] ). 

• Einige in anderen Sprachen gebräuchliche Kontrollstrukturen, wie do/while [13] , sind in Python nicht vorhanden 

und müssen auf andere Weise realisiert werden (z. B. durch „while True: … break“). 

• Auf Multiprozessor-Systemen behindert der sogenannte Global Interpreter Lock (GIL) von CPython die Effizienz 

von Python-Anwendungen, die Multithreading benutzen. [17] (Diese Beschränkung existiert unter Jython oder 

IronPython nicht.) Es ist nicht geplant, den GIL zu ersetzen. Stattdessen wird empfohlen, statt Threads mehrere 

[18] [19] 

miteinander kommunizierende Prozesse zu verwenden.


• In den aktuell vorherrschenden Implementationen ist die Geschwindigkeit niedriger als bei vielen kompilierbaren 

Sprachen [20] , aber ähnlich wie bei Perl [21] , PHP [22] oder Smalltalk [22] und höher als bei Ruby. [23] Das ist zum 

Teil gewollt: Bei der Entwicklung von CPython geht Klarheit vor Performanz. [24] Dabei beruft man sich auf 

Autoritäten wie Donald Knuth und Tony Hoare, die von verfrühter Optimierung abraten. Wenn 

Performanzprobleme auftreten, die nicht durch Optimierung des Python-Codes gelöst werden können [25] , setzt 

man einen JIT-Compiler wie Psyco ein oder lagert zeitkritische Funktionen in maschinennähere Sprachen wie C 

aus. 

Literatur 

Für den Einstieg 

• Hans Petter Langtangen: A Primer on Scientific Programming with Python. [26] Springer 2009. ISBN 

978-3-642-02474-0 

• Mark Pilgrim: Dive Into Python. [27] Springer, New York 2004. ISBN 1-59059-356-1 (Download verfügbar) 

• Mark Pilgrim: Dive Into Python 3. [28] Springer, New York 2009. ISBN 1-4302-2415-0 (Download verfügbar) 

• Mark Pilgrim, Florian Wollenschein: Python 3 - Intensivkurs [29] Springer, Berlin 2010. ISBN 978-3-642-04376-5 

(Deutsche Übersetzung von Dive Into Python 3) 

• C H.Swaroop: A byte of Python. [30] (Download verfügbar) 

• Thomas Theis: Einstieg in Python. Galileo Press, Bonn 2002. ISBN 3-89842-227-5 

• Thomas Theis: Einstieg in Python 3 Galileo Press Bonn 2009. ISBN 978-3-8362-1406-3 

• Mark Lutz, David Ascher: Einführung in Python. O’Reilly, Cambridge 2000. ISBN 3-89721-129-7 

• Martin Uzák: Python 2.x. Das Einsteigerseminar. bhv, Bonn 2002. ISBN 3-8266-7206-2 

• Peter Walerowski: Python - Grundlagen und Praxis. Addison-Wesley, München 2008. ISBN 3-8273-2517-X 

• Ivan van Laningham: Jetzt lerne ich Python. Markt+Technik, München 2000. ISBN 3-8272-5843-X 

Referenzen 

• Martin von Löwis, Nils Fischbeck: Python 2 – Einführung und Referenz der objektorientierten Skriptsprache, 

Addison-Wesley, ISBN 3-8273-1691-X 

• Michael Weigend: Python GE-PACKT., mitp-Verlag, ISBN 3-8266-0724-4 

• Michael Lauer: Python und GUI-Toolkits, mitp-Verlag, ISBN 3-8266-0844-5 

Weiterführendes 

• Peter Kaiser, Johannes Ernesti: Python - Das umfassende Handbuch - Aktuell zu Python 2.5 [31] , Galileo Press, 

ISBN 978-3-8362-1110-9, Download verfügbar 

• Farid Hajji: Das Python-Praxisbuch, Addison-Wesley, ISBN 978-3-8273-2543-3 

• Stefan Schwarzer: Python Workshop, Addison-Wesley, ISBN 3-8273-1880-7 

• Michael Weigend: Objektorientierte Programmierung mit Python, mitp-Verlag, ISBN 3-8266-0966-2 

• Hans P. Langtangen: Python Scripting for Computational Science, Springer, ISBN 3-540-43508-5 

• Thomas W. Christopher: Python Programming Patterns, Prentice Hall, ISBN 0-13-040956-1 

• Gregor Lingl: Python für Kids, mitp-Verlag, ISBN 3-8266-0951-4 

• Jason R. Briggs: Snake Wrangling for Kids – Learning to Program with Python, engl. [32] . Für achtjährige und 

ältere Kinder, Creative Commons Lizenz. 

• Schlangengerangel für Kinder - Programmieren Lernen für Kinder [33] Deutsche Version von Snake Wrangling 

for Kids. Für achtjährige und ältere Kinder, Creative Commons Lizenz.


Weblinks 

• www.python.org [34] (englisch) 

• Übersetzung des offiziellen Tutorials zur Version 3.1 [35] 

• Kurs – Einstieg in Python [36] 

• Eric S. Raymond über seine Erfahrungen mit Python [37] (englisch) 

• Kurzeinführung „Learn Python in 10 minutes“ [38] (englisch) 

• Python Tutorial für Anfänger inkl. Objektorientierung und Threads [39] 

• A Byte of Python - Umfangreiches und für Einsteiger geeignetes Python Tutorial [30] (deutsch) 

Referenzen 

[1] Python License (http:/ / www. python. org/ psf/ license/ ) 

[2] http:/ / www. python. org/ 

[3] What is Python Good For? (http:/ / www. python. org/ doc/ faq/ general/ #what-is-python-good-for). General Python FAQ. Python 

Foundation. Abgerufen am 5. September 2008. 

[4] What is Python? Executive Summary (http:/ / www. python. org/ doc/ essays/ blurb/ ). Python documentation. Python Foundation. Abgerufen 

am 21. März 2007. 

[5] Offizielle Python FAQ (http:/ / www. python. org/ doc/ faq/ general/ #why-is-it-called-python), sowie Python Tutorial, Kapitel 1 (http:/ / 

docs. python. org/ tut/ node3. html) 

[6] Cobra (http:/ / cobra-language. com/ ) 

[7] http:/ / boa-constructor. sourceforge. net 

[8] http:/ / docs. python. org/ ref/ keywords. html 

[9] heise.de: Python 2.6 öffnet Wege zu Version 3 (http:/ / www. heise. de/ newsticker/ Python-2-6-oeffnet-Wege-zu-Version-3--/ meldung/ 

116831) vom 2. Oktober 2008, abgerufen am 4. Oktober 2008 

[10] http:/ / my. safaribooksonline. com/ 0596002815/ lpython2-CHP-7-SECT-6 

[11] PyMite in der Python Wiki (http:/ / wiki. python. org/ moin/ PyMite) 

[12] OLPC-Wiki: „ Python für den 100-Dollar-Laptop (http:/ / wiki. laptop. org/ go/ Python)“ 

[13] http:/ / web. archive. org/ web/ 20031002184114/ www. amk. ca/ python/ writing/ warts. html 

[14] Guido van Rossum: Why explicit self has to stay (http:/ / neopythonic. blogspot. com/ 2008/ 10/ why-explicit-self-has-to-stay. html) 

[15] http:/ / mail. python. org/ pipermail/ python-ideas/ 2007-January/ 000073. html 

[16] http:/ / www. python. org/ dev/ peps/ pep-3135/ 

[17] http:/ / blog. snaplogic. org/ ?p=94 

[18] http:/ / www. python. org/ doc/ faq/ library/ #can-t-we-get-rid-of-the-global-interpreter-lock 

[19] http:/ / www. artima. com/ weblogs/ viewpost. jsp?thread=214235 

[20] Python–C (http:/ / shootout. alioth. debian. org/ u32q/ benchmark. php?test=all& lang=python& lang2=gcc& box=1) 

[21] Python–Perl (http:/ / shootout. alioth. debian. org/ u32q/ benchmark. php?test=all& lang=python& lang2=perl) 

[22] Benchmark-Vergleich Python–PHP (http:/ / shootout. alioth. debian. org/ u32q/ benchmark. php?test=all& lang=python& lang2=php) 

[23] Benchmark-Vergleich Python–Ruby (http:/ / shootout. alioth. debian. org/ u32q/ benchmark. php?test=all& lang=python& lang2=ruby) 

[24] Python Culture (http:/ / www. python. org/ dev/ culture/ ) 

[25] Python Patterns – An Optimization Anecdote (http:/ / www. python. org/ doc/ essays/ list2str. html) 

[26] http:/ / www. springer. com/ 978-3-642-02474-0/ 

[27] http:/ / diveintopython. org/ 

[28] http:/ / diveintopython3. org/ 

[29] http:/ / www. python3-intensivkurs. de 

[30] http:/ / abop-german. berlios. de/ 

[31] http:/ / www. galileocomputing. de/ openbook/ python/ 

[32] http:/ / www. briggs. net. nz/ log/ writing/ snake-wrangling-for-kids/ 

[33] http:/ / code. google. com/ p/ swfk-de/ 

[34] http:/ / www. python. org 

[35] http:/ / tutorial. pocoo. org/ 

[36] http:/ / www. linux-user. de/ ausgabe/ 2006/ 09/ 080-python-1/ 

[37] http:/ / www. linuxjournal. com/ article/ 3882 

[38] http:/ / www. poromenos. org/ tutorials/ python 

[39] http:/ / www. sunjy. de/ python/ index. html

REALbasic 147 

REALbasic 

REALbasic 

Entwickler: REAL Software, Inc. 

Aktuelle Version: 2010 Release 1 (9. Februar 2010) 

Betriebssystem: Windows, MacOSX, Linux 

Kategorie: Programmiersprache 

Lizenz: Kommerziell 

Deutschsprachig: ja 

www.realsoftware.com [1] 

REALbasic ist eine objektorientierte Programmiersprache mit Visuellen Entwicklungsumgebungen für Mac OS X, 

Linux und Windows und basiert in ihren Befehlen und der Syntax auf der Programmiersprache BASIC. 

Es ähnelt sehr stark Visual Basic 6, so dass es derzeit sehr beliebt bei Visual-Basic-6-Anhängern ist, die nicht zu 

.NET wechseln wollen. RealBasic wird mit einer großen Bibliothek an Elementen ausgeliefert. Eine eigene Version 

der Entwicklungsumgebung für Linux ist seit 2005 verfügbar. 

REALbasic-Programmcode kann ohne Änderungen auch auf den jeweils anderen Plattformen compiliert werden und 

erzeugt dabei Stand-Alone-Anwendungen für das jeweilige System (es wird keine zusätzliche Laufzeitumgebung 

benötigt). Für jeweils plattformspezifische Änderungen sind Direktiven implementiert, die es erlauben, den 

Quellcode entsprechend anzupassen. Bis zur Version 5.5.5 lief die REALbasic-IDE noch nativ auf Mac OS 9, 

nachfolgende Versionen konnten bis 2007 Release 3 noch Mac OS 9 Programme kompilieren. 

In Deutschland wird REALbasic von ASH vertrieben. 

Geschichte 

REALbasic wurde ursprünglich von dem US-Amerikaner Andrew Barry unter dem Namen CrossBasic entwickelt, 

damals als reine Macintosh-Software. Da CrossBasic einerseits sehr einfach zu bedienen war, andererseits aber 

durchaus professionelle Programme damit entwickelt werden konnten, entstand schnell eine große Community. Aus 

dem ursprünglichen Hobby-Projekt (Barry war hauptberuflich Spiele-Entwickler) wurde Ende der 1990er Jahre eine 

kommerzielle Software: Der heutige Besitzer und CEO, Geoff Perlman, kaufte das Projekt und gründete in Austin 

(Texas) die REAL Software Inc. Trotz einiger Anlaufschwierigkeiten ist REALbasic heute die führende 

BASIC-Entwicklungsumgebung auf dem Mac. 

Literatur 

• Burkhard Piereck: REALbasic für Einsteiger und Umsteiger. Smart Books Publishing AG, 2009, ISBN 

978-3908497905. 

Weblinks 

• Offizielle REALbasic Homepage [2] 

• RealBasic.de - Deutsches Nutzer-Forum [3] 

• REALbasic Developer Magazin - englische Zeitschrift zu REALbasic [4]

REALbasic 148 

Referenzen 

[1] http:/ / www. realsoftware. com/ 

[2] http:/ / www. realbasic. com 

[3] http:/ / www. realbasic. de/ forum/ 

[4] http:/ / www. rbdeveloper. com/ 

Ruby (Programmiersprache) 



Ruby 

Offizielles Logo 

Basisdaten 

Entwickler: Yukihiro Matsumoto und andere 


1.9.1 (31. Januar 2009 [1] ) 

Typisierung: dynamisch („Duck-Typing“) 

wichtige Implementierungen: Ruby MRI, YARV, JRuby, Rubinius (siehe unten) 

Einflüsse: Smalltalk, Perl, Python, LISP, Scheme, CLU, Eiffel, Ada, Dylan, JavaScript 

Beeinflusste: Groovy 


Lizenz: GPL und eigene (siehe Nutzungsbedingungen) 

ruby-lang.org [2] 

Ruby (engl. für Rubin) ist eine moderne, vielseitige höhere Programmiersprache, die Mitte der Neunziger Jahre von 

Yukihiro Matsumoto entworfen wurde. 

Ruby ist interpretiert und objektorientiert, unterstützt aber mehrere weitere Programmierparadigmen (unter anderem 

Prozedurale und Funktionale Programmierung sowie Nebenläufigkeit), bietet dynamische Typisierung, Reflexion 

und Automatische Speicherbereinigung.


Geschichte 

Aus Unzufriedenheit über verfügbare Skriptsprachen begann Yukihiro 

„Matz“ Matsumoto 1993, an einer eigenen Sprache zu arbeiten, und 

gab am 21. Dezember 1995 die erste Version von Ruby, 0.95, frei. [3] 

Den Namen, hergeleitet vom Edelstein Rubin, wählte er als Anspielung 

auf die Programmiersprache Perl. [4] Zunächst wurde Ruby mangels 

englischsprachiger Dokumentation fast ausschließlich in Japan benutzt, 

wo es einen ähnlichen Stellenwert erlangte wie Perl und Python in 

Europa und Amerika. Um das Jahr 2000 wurden Aktivitäten gestartet, 

um Ruby auch außerhalb Japans bekannt zu machen, woraufhin mit der 

Zeit auch englische Dokumentationen entstanden. Inzwischen gibt es 

auch dutzende deutschsprachige Bücher zu Ruby im Allgemeinen und 

speziellen Themen. 

Heute wird die Sprache als Open-Source-Projekt weitergepflegt. 

Merkmale 

Programmierparadigmen 

Der Entwickler von Ruby, Yukihiro Matsumoto. 

Ruby ist eine objektorientierte Sprache. Die Sprache wurde aber ähnlich wie C++ als „Multiparadigmen-Sprache“ 

entworfen. Das bedeutet, dass es dem Entwickler offen steht, weitere Programmierparadigmen zur Erstellung seiner 

Programme zu nutzen. Die verbreitetsten Paradigmen sollen im Folgenden beschrieben werden. 

Objektorientierte Programmierung 

Ruby ist wie Smalltalk vollständig objektorientiert: Alle Datentypen sind in Ruby Objekte, auch solche, die in vielen 

anderen Sprachen als primitive Datentypen gelten, wie etwa Zahlen oder Zeichenketten. 

Ruby unterstützt mehrere Ansätze der Vererbung. 

Klassenbasierte Objektorientierung 

Eine Klasse kann wie folgt definiert werden: 

class Auto 

end 

def beschleunigen 

end 

puts "BrumBrumBrum" 

auto1 = Auto.new 

auto1.beschleunigen 

Ausgabe: 

BrumBrumBrum 

Auto erbt dabei automatisch von der Mutterklasse Object. Eine Klasse, die von einer anderen Klasse als Object erbt, 

wird so definiert:


class GutesAuto < Auto 

end 

def bremsen 

end 

puts "Quietsch" 

auto2 = GutesAuto.new 


auto2.bremsen 

Ausgabe: 

BrumBrumBrum 

Quietsch 

Die Klasse GutesAuto erbt alle Methoden der Klasse Auto, u. a. auch beschleunigen. Zusätzlich wird für GutesAuto 

die Methode bremsen definiert. 

Prototypenbasierte Objektorientierung 

Ruby unterstützt zudem, ähnlich wie JavaScript oder Io, prototypenbasierte Objektorientierung. 

Das obige Beispiel mit Prototypen realisiert: 

auto1 = Object.new 

def auto1.beschleunigen 

end 



auto2 = auto1.clone 

def auto2.bremsen 

end 



auto2.bremsen 

Ausgabe: 

BrumBrumBrum 

BrumBrumBrum 

Quietsch


Objektorientierung mit Mixins 

Bis vor einiger Zeit wurden Mixins als reine Ergänzung zu klassenbasierter Objektorientierung angesehen. 

Spätestens aber seit Sprachen wie Potion ist klar, dass es sich hierbei um ein eigenes Konzept der Objektorientierung 

handelt. Dieses wird auch von Ruby unterstützt. 

In Ruby sind Mixins Module, die in andere Objekte eingebunden werden. Die Methoden des Beispiels aus den 

beiden oberen Abschnitten ließe sich zum Beispiel so in Module teilen: 

module Gaspedal 

end 

def beschleunigen 

end 


module Bremse 

end 

def bremsen 

end 


Ein Auto mit Gaspedal und Bremsen ließe sich dann wie folgt zusammenbauen: 

auto = Object.new 

auto.extend Gaspedal 

auto.extend Bremse 

Natürlich lässt sich das mit Klassen kombinieren: 

class Auto 

end 

include Gaspedal 

class GutesAuto < Auto 

end 

include Bremse 

Aber auch mit Prototypen ist es nutzbar: 

auto1 = Object.new 

auto1.extend Gaspedal 

auto2 = auto1.clone 

auto2.extend Bremse


Prozedurale Programmierung 

Im Gegensatz zu Sprachen wie Java und C# ist es in Ruby nicht notwendig, seine Programme explizit in einer Klasse 

zu definieren. Da jedes Ruby-Programm in einem globalen main-Objekt erstellt wird, ist dieses sich oft 

wiederholende Sprachkonstrukt unnötig. Stattdessen kann ein Programm auch aus Prozeduren aufgebaut werden. 

Folgender Codeabschnitt ist bereits ein vollständig lauffähiges Ruby-Programm: 

def gruessen 

end 

puts "Hallo Welt!" 

gruessen 

Ausgabe: 

Hallo Welt! 

Funktionale Programmierung 

Weil in Ruby jeder Ausdruck einen Wert hat, lassen sich Probleme funktional behandeln. 

Im folgenden Beispiel gibt das case-Konstrukt je nach Wert der Variable sprache einen anderen String zurück. 

gruss = case sprache 

end 

when "Deutsch" then "Hallo Welt" 

when "Englisch" then "Hello, world" 

when "Japanisch" then "konnichiwa sekai" 

else raise "Unbekannte Sprache" 

Über ein Lambda-Konstrukt kann man einen Codeblock in einer Funktionsvariablen speichern. 

print_function = lambda { |item| print item + 1 } 

[1,2,3].each &print_function 

# >> 234 

Weitere Paradigmen 

Ruby unterstützt Metaprogrammierung, aspektorientierte Programmierung durch Active Support oder AspectR [5] 

und kontextorientierte Programmierung [6] durch ContextR. [7] 

Prinzipien 

Prinzip der geringsten Überraschung 

Ruby folgt dem Prinzip der geringsten Überraschung (kurz POLS für „Principle of least surprise“). Rubys Designer 

versuchen, die Sprache so zu gestalten, dass Programmierer sie intuitiv nutzen können und möglichst wenig von 

ihrem Verhalten überrascht werden. Matsumoto gibt an, die Sprache primär auf seine eigenen Bedürfnisse 

ausgerichtet zu haben: 

„Das Prinzip der geringsten Überraschung ist das Prinzip meiner geringsten Überraschung. Und es ist das 

Prinzip der geringsten Überraschung nachdem Du Ruby sehr gut gelernt hast.“ 

– Yukihiro „Matz“ Matsumoto


Duck Typing 

Die Duck-Typing-Philosophie von Ruby basiert auf der Idee, den Typ eines Objekts nicht von dessen Klasse, 

sondern von dessen Methoden abhängig zu machen. 

class Ente 

end 

def beschreibung 

end 

"Eine graue Ente" 

def sprechen 

end 

"Quak!" 

class Kuh 

end 

def beschreibung 

end 

"Eine dicke Kuh" 

def sprechen 

end 

"Muuuh!" 

def lass_sprechen tier 

end 

puts tier.beschreibung+" macht "+tier.sprechen 

lass_sprechen Ente.new 

lass_sprechen Kuh.new 

Ausgabe: 

Eine graue Ente macht Quak! 

Eine dicke Kuh macht Muuuh! 

Im Beispiel ist es für lass_sprechen unerheblich, von welcher Klasse tier ist, es ist nur wichtig, dass die Methoden 

beschreibung und sprechen verstanden werden. 

Ruby bietet Exceptions, Introspection und andere Mechanismen, um das Duck Typing abzusichern, sofern der 

Programmierer das wünscht.


Syntax 

Besonderheiten 

Zeilenumbrüche markieren das Ende einer Anweisung, Semikolons bewirken dasselbe. Sonstiger Whitespace hat 

keine Bedeutung. 

Klammern um Argumente können bei Eindeutigkeit weggelassen werden, sowohl bei der Deklaration einer 

Methode, als auch beim Aufruf. Der zuletzt berechnete Wert einer Methode ist gleichzeitig ihr Rückgabewert: 

def sperre text 

end 

text.split("").join " " 

puts sperre "Syntaktischer Zucker!" 

Ruby unterscheidet fünf verschiedene Gültigkeitsbereiche: 

• Normalerweise ist eine Variable lokal und nur innerhalb der umgebenden Methode gültig. 

• Ein @ vor Variablen deklariert diese als Attribute, sie werden dann dauerhaft der Instanz zugeordnet und für 

diese sichtbar. 

• Ein vorangestelltes @@ macht Variablen zu Klassenvariablen, die zur umgebenden Klasse gehören. 

• Mit $ werden Variablen global und sind damit im gesamten Programm sichtbar. 

• Schließlich gibt es Variablen, die nur innerhalb eines Blocks gültig sind. 

Blöcke 

Anstatt von For-Schleifen macht man in Ruby häufig Gebrauch von sogenannten Blöcken. Dies sind Codeabschnitte, 

die nach bestimmten Vorgaben, etwa für alle Elemente einer Datenstruktur, ausgeführt werden. Sie können unter 

anderem benutzt werden, um Strukturen auszuwerten oder zu manipulieren. Ausdrücke wie 

array.each do |i| 

end 

... 

oder in der Kurzschreibweise 

array.each { |i| ... } 

iterieren über array, wobei dem Block in jedem Iterationsschritt ein Visitor für das aktuelle Element mit der 

Bezeichnung i übergeben wird. Mit Blöcken werden elegante Konstruktionen wie 5.times{ ... } oder array.sort_by{|i| 

i.size} möglich. 

Iteratoren, also Methoden, die Blöcke aufrufen, können auch selbst definiert werden: 

def mach_zweimal 

end 

yield 

yield 

mach_zweimal { puts "Block aufgerufen!" } 

Ausgabe: 

Block aufgerufen! 

Block aufgerufen!


Bestandteile 

Interaktive Ruby-Shell 

Interactive Ruby (kurz: irb) ist ein Read-Eval-Print Loop (kurz REPL) für Ruby, mit welchem der Anwender 

interaktiv Ruby programmieren kann. Er kann zum Analysieren und Testen eingesetzt werden: 

irb(main):001:0> (5 + 7) * 2 

=> 24 

irb(main):002:0> ((5 + 7) * 2).to_s.reverse 

=> "42" 

irb(main):003:0> "Ein Beispielstring".size 

=> 18 

Irb wird mit dem Ruby-Interpreter ausgeliefert, kann aber auch mit Hilfe von TryRuby [8] im Browser ausgeführt 


RDoc und ri 

RDoc ist ein Software-Dokumentationswerkzeug, welches aus Ruby- und C-Quelltexten automatisch 

HTML-Dokumentationsdateien erstellt. Weiterhin wird eine Datenbank aufgebaut, die mit dem Tool ri durchsucht 

werden kann. RDoc und ri sind Bestandteil der Standarddistribution und werden zusammen mit dem Interpreter 

ausgeliefert. 

RubyGems 

RubyGems (kurz: gems) ist das offizielle Paketsystem für Ruby. Mit ihm hat der Anwender die Möglichkeit mehrere 

Versionen eines Programmes oder einer Bibliothek kontrolliert zu installieren und wieder zu entfernen. Durch die 

Versionierung der Pakete können alte und neue Versionen problemlos nebeneinander existieren. 


Die ursprüngliche Referenzimplementierung von Ruby (aktuelle Version: 1.9.1) wurde von Yukihiro „Matz“ 

Matsumoto als Interpreter in C entworfen. Er wird oft als CRuby, MRI (Matz's Ruby Interpreter) oder MatzRuby 

bezeichnet und ist derzeit am weitesten verbreitet. Den Kern bildet YARV (kurz für Yet Another Ruby VM), eine 

virtuelle Maschine. Statt ein Rubyprogramm direkt auszuführen, wird es so zunächst in Bytecode übersetzt und dann 

von YARV interpretiert, wodurch sich ein Geschwindigkeitsvorteil ergibt. Weiterhin enthält diese Version eine 

leistungsstarke Regexp-Maschine namens Oniguruma und unterstützt Multibyte-Zeichensätze wie UTF-8. Die 

Vorgängerversion (1.8.7) wird vorerst weiter gepflegt, da 1.9.1 nicht kompatibel zu dieser ist und eine Vielzahl von 

Programmen deshalb noch nicht fehlerfrei auf der neuen Version läuft. 

Der offizielle Interpreter läuft auf den folgenden Betriebssystemen: 

• POSIX-kompatible Systeme (u. a. Linux, BSD und Mac OS X) 

• Microsoft Windows (u. a. 2000 und XP) 

Inzwischen sind mehrere alternative Implementierungen von Ruby verfügbar, unter anderem: 

• JRuby, eine Neuimplementierung des Ruby-Interpreters in Java mit dem Ziel, Ruby nahtlos in die Java-Plattform 

zu integrieren. JRuby ist fast vollständig kompatibel zu Ruby 1.8.7, teilweise auch zu 1.9. JRuby ist zudem 

kompatibel zu einigen Ruby-Erweiterungen von Rubinius (Foreign Function Interface, Multi-VM-API). 

• Rubinius, eine von Smalltalk-80 inspirierte Implementierung. Abgesehen von der virtuellen Maschine ist 

Rubinius vollständig in Ruby geschrieben. Rubinius is nahezu vollständig kompatibel zu Ruby 1.8.7 und hat 

experimentellen Support für 1.9. Rubinius nutzt die Low Level Virtual Machine (LLVM) und ist kompatibel mit


C Erweiterungen der Referenzimplementierung. 

• Microsofts IronRuby [9] und Gardens Point Ruby.NET [10] , die Ruby ins .NET-Framework integrieren sollen 

und in C# implementiert werden. 

• Cardinal [11] , ein Interpreter für die virtuelle Maschine Parrot. 

• MagLev [12] ist eine Implementierung des Unternehmens Gemstone für deren proprietäre Smalltalk VM. 

• MacRuby [13] ist eine Implementierung in Objective-C von Apple, die bis Version 0.4, wie Ruby 1.9, YARV 

nutzt, ab Version 0.5 allerdings, wie Rubinius, auf die LLVM setzt. MacRuby ist als einzige Implementierung nur 

zu Ruby 1.9 kompatibel, nicht mehr zu Ruby 1.8. 

• tinyrb [14] ist eine minimalistische Implementierung, angelehnt an die virtuellen Maschinen von Lua und Potion 

[15] . Es wird keine vollständige Kompatibiblität zu Ruby erreicht werden: Zwar soll jedes Programm, dass tinyrb 

ausführen kann, auch von Ruby ausführbar sein, jedoch soll tinyrb nicht jedes Rubyprogramm ausführen können. 

• Ruby Enterprise Edition [16] ist eine modifizierte Version der Referenzimplementierung, bei der im 

wesentlichen der Garbage Collector neu implementiert wurde. (Siehe dazu: Kritik) 

• Eine auf ABAP aufbauende Neuimplementierung namens Blue Ruby wird im Moment von SAP entwickelt. Als 

einzige der hier aufgeführten Implementierungen ist Blue Ruby derzeit nicht quelloffen. 

Ein wichtiges Merkmal ist hierbei, ob diese Implementierungen in der Lage sind, Ruby On Rails auszuführen. 

Derzeit können dies neben der Referenzimplementierung nur JRuby [17] , Rubinius [18] und die Ruby Enterprise 

Edition [19] (Stand: November 2009). 

Die Kompatibilität zur Referenzimplementierung wird durch das RubySpec Projekt [20] überprüft, das im Moment 

von allen genannten Implementierungen, mit Ausnahme von tinyrb und Cardinal, genutzt wird (Stand: November 

2009). Es stellt dabei sowohl eine Testsuite als auch eine Spezifikation für Ruby 1.8 und 1.9 dar. RubySpec war 

ursprünglich ein Teil von Rubinius, wurde aber ausgelagert und nun auch von einer Vielzahl anderer Entwickler 

vorangetrieben. 

Kritik 

Kritik an der Sprache: 

• Da Variablen vor Gebrauch nicht deklariert werden müssen, können bei Tippfehlern unerwartete Laufzeitfehler 

auftreten. 

• Ruby ist nicht immer abwärtskompatibel. [21] 

• Metaprogrammierung und Monkeypatching erlauben es einem Codestück, alle Klassen und Objekte des 

Prozesses, in dem es ausgeführt wird, zu ändern. [22] 

• Ruby hatte bis vor kurzem keine offizielle Spezifikation. Allerdings wurde RubySpec von Matz als Spezifikation 

angenommen. Zudem gibt es von Matz und anderen Entwicklern das Bestreben, eine weitere Spezifikation zu 

erstellen, mit dem Ziel, einen ISO-Standard zu etablieren. [23] Ein erster Entwurf für eine solche Spezifikation 

wurde am 27. November 2009 veröffentlicht. [24] 

Kritik an der Referenzimplementierung: 

• Der Garbage Collector manipuliert die Speichereinträge für Objekte direkt, sodass Copy-On-Write-Mechanismen 

des Betriebssystems ausgehebelt werden und es möglich ist, dass ein Rubyprogramm nach dem Durchlaufen des 

Garbage Collectors eventuell mehr Speicher belegt als zuvor. [25] 

• Der Garbage Collector benutzt Mark-And-Sweep, was eine relativ simple, aber ineffiziente Strategie darstellt. [26] 

• YARVs Global Interpreter Lock führt dazu, dass mehrere Threads eines Prozesses nicht gleichzeitig auf 

[27] [28] 

verschiedenen Prozessoren ausgeführt werden können.


Sonstiges 

Anwendungen und Bibliotheken 

Mit RubyForge [29] und dem Ruby Application Archive [30] (RAA) stehen zwei Repositorien zur Verfügung, die 

zusammen über 7000 Anwendungen und Bibliotheken beherbergen. 

Als derzeit bedeutendste Anwendung, die auf Ruby basiert, ist das Web-Framework Ruby on Rails zu nennen. 

Nutzungsbedingungen 

Ruby ist freie Software. Aufgrund dessen ist es kostenlos nutzbar und im Quelltext verfügbar. Dadurch ergibt sich 

die Möglichkeit, die Sprache an seine eigenen Bedürfnisse anzupassen oder sie in eigene Programme einzubinden. 

Der Interpreter und die Standardbibliothek von Ruby sind grundsätzlich unter den Bedingungen der GPL nutzbar. 

Des Weiteren besteht die Möglichkeit, Ruby unter anderen Konditionen zu verwenden. [31] 

Literatur 

Für Einsteiger 

• Daniel Bovensiepen: Das Einsteigerseminar Ruby. vmi Buch, Heidelberg 2007, ISBN 978-3-8266-7459-4 

• Sascha Kersken: Praxiswissen Ruby. O’Reilly, 2007, ISBN 978-3-89721-478-1 

• Kevin C. Baird: Das Ruby-Praxisbuch. Franzis, 2008, ISBN 978-3-7723-7904-8 

Gesamtdarstellungen 

• Dave Thomas: Programming Ruby, Second Edition. Pragmatic Bookshelf, 2004, ISBN 0-9745140-5-5 (englisch) 

• Hal Fulton: The Ruby Way. Addison-Wesley Professional, 2006, ISBN 978-0-672-32884-8 (englisch) 

Für Fortgeschrittene 

• Lucas Carlson, Leonard Richardson: Ruby Cookbook. O’Reilly Media, 2006, ISBN 978-0-596-52369-5 (englisch) 

• Russ Olsen: Design Patterns in Ruby. Addison-Wesley Professional, 2007, ISBN 978-0-321-49045-2 (englisch) 

Referenzen 

• Michael Fitzgerald: Ruby: kurz & gut. O’Reilly, 2007, ISBN 978-3-89721-534-4 

Weblinks 

• Offizielle Webseite von Ruby [2] 

• Zusammenstellung von Tutorials zu Ruby [32] 

• Dokumentationssammlung zu Ruby [33] (englisch) 

• Deutsches Rubyforum [34] 

• Links zum Thema Ruby [35] im Open Directory Project 

• Deutsches Magazin für Ruby on Rails [36]


Referenzen 

[1] Ruby 1.9.1 released (http:/ / www. ruby-lang. org/ en/ news/ 2009/ 01/ 30/ ruby-1-9-1-released/ ) 

[2] http:/ / www. ruby-lang. org/ de/ 

[3] RubyConf: History of Ruby (http:/ / blog. nicksieger. com/ articles/ 2006/ 10/ 20/ rubyconf-history-of-ruby) 

[4] Ein Interview mit dem Schöpfer von Ruby (http:/ / www. linuxdevcenter. com/ pub/ a/ linux/ 2001/ 11/ 29/ ruby. html) 

[5] http:/ / aspectr. sourceforge. net/ 

[6] http:/ / www. swa. hpi. uni-potsdam. de/ cop/ 

[7] http:/ / contextr. rubyforge. org/ 

[8] http:/ / tryruby. sophrinix. com/ 

[9] http:/ / www. ironruby. net/ 

[10] http:/ / plas. fit. qut. edu. au/ rubynet/ 

[11] http:/ / cardinal2. rubyforge. org/ 

[12] http:/ / ruby. gemstone. com/ 

[13] http:/ / www. macruby. org/ trac/ wiki/ MacRuby 

[14] http:/ / macournoyer. com/ blog/ 2009/ 02/ 12/ tinyrb/ 

[15] http:/ / github. com/ whymirror/ potion 

[16] http:/ / www. rubyenterpriseedition. com 

[17] http:/ / wiki. jruby. org/ wiki/ JRuby_on_Rails 

[18] http:/ / blog. fallingsnow. net/ 2008/ 05/ 17/ rails-on-rubinius/ 

[19] http:/ / www. rubyenterpriseedition. com/ 

[20] http:/ / rubyspec. org/ 

[21] http:/ / www. infoq. com/ news/ 2007/ 12/ ruby-19 

[22] http:/ / avdi. org/ devblog/ 2008/ 02/ 23/ why-monkeypatching-is-destroying-ruby/ 

[23] http:/ / www. ruby-forum. com/ topic/ 169195 

[24] http:/ / ruby-std. netlab. jp/ 

[25] http:/ / blog. beaver. net/ 2005/ 03/ ruby_gc_and_copyonwrite. html 

[26] http:/ / rubyconf2008. confreaks. com/ how-ruby-can-be-fast. html 

[27] http:/ / www. infoq. com/ news/ 2007/ 05/ ruby-threading-futures 

[28] http:/ / www. igvita. com/ 2008/ 11/ 13/ concurrency-is-a-myth-in-ruby/ 

[29] http:/ / rubyforge. org/ 

[30] http:/ / raa. ruby-lang. org/ 

[31] Rubys Lizenzbedingungen (http:/ / www. ruby-lang. org/ en/ about/ license. txt) 

[32] http:/ / www. ruby-lang. org/ de/ documentation/ 

[33] http:/ / ruby-doc. org/ 

[34] http:/ / rubyforen. de/ 

[35] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ Ruby/ 

[36] http:/ / it-republik. de/ railsway/ magazin-ausgaben/ Ruby-%26-Mac-000306. html


Smalltalk (Programmiersprache) 

Smalltalk 

Logo von Smalltalk 

Basisdaten 

Entwickler: diverse 

Aktuelle Version: Smalltalk 80 (1980) 

Einflüsse: Lisp, Simula 

Beeinflusste: Objective-C, Java, Ruby 

Betriebssystem: Windows, Linux, Mac OS X, 

uvm. 

Lizenz: implementierungsspezifisch 

http:/ / smalltalk. org 

Smalltalk ist eine dynamische, im Original untypisierte objektorientierte Programmiersprache und zugleich eine 

vollständige Entwicklungsumgebung, die in den 1970er Jahren am Xerox PARC Forschungszentrum durch Alan 

Kay, Dan Ingalls, Adele Goldberg und andere entwickelt wurde. Sie wurde allgemein unter dem Namen 

Smalltalk-80 freigegeben und hat die Entwicklung vieler späterer Programmiersprachen, wie z. B. Objective-C, Java 

und Ruby beeinflusst. Smalltalk wurde von Lisp und Simula mit seinem Klassen-Konzept beeinflusst und wurde 

nach Simula-67 die erste populäre objektorientierte Programmiersprache. 

Smalltalk ist im Gegensatz zu Sprachen wie C++ oder Java eine rein objektorientierte Programmiersprache, d. h. 

Daten wie Integer, Character o. ä., die in anderen objektorientierten Sprachen z. T. als primitive Datentypen 

repräsentiert werden, werden in Smalltalk ebenfalls über Objekte und zugehörige Klassen realisiert. Die 

Smalltalk-Entwicklungsumgebung enthielt viele Ideen, die später mit der Macintosh- und Atari-TOS/GEM- und 

dann später auch Windows-Benutzeroberfläche verbreitet wurden. Verwendet wurde ein Grafikbildschirm mit 

verschiebbaren Fenstern, Aufklappmenüs und Schriften von verschiedener Größe. Eine Maus mit drei Tasten – rot, 

blau und gelb – diente erstmals als zusätzliches Eingabegerät. Das Model-View-Controller-Konzept (MVC) spielte 

in der Smalltalk-80-Entwicklungsumgebung eine wesentliche Rolle. 

Wichtige Eigenschaften von Smalltalk 

• Alles in Smalltalk ist ein Objekt, auch Zeichenketten, Integer, Boolesche Werte, Klassen(-definitionen), 

ausführbarer Code, Stackframes, der Speicher, Codeblöcke etc. 

• Objekte werden dadurch aktiviert, dass man ihnen Nachrichten (Messages) schickt. Dies führt dazu, dass die 

entsprechende Methode (Funktion) des Objekts ausgeführt wird. 

• Der gesamte Quelltext ist i. d. R. offen und kann somit verändert werden. Nur sehr wenige Methoden greifen auf 

echte 'Primitives' der VM (virtuellen Maschine) zurück. 

• Dynamische Bindung – erst zur Laufzeit wird ermittelt, welche Methode tatsächlich aufgerufen wird. Eine frühe 

(„statische“) Bindung, wie dies bei der statischen Typisierung vorgesehen ist, wurde in der Smalltalk 

Programmiersprache bewusst ausgespart. 

• Vererbung: Jede Klasse (außer der Wurzelklasse Object) ist von genau einer Oberklasse abgeleitet, deren 

Verhalten sie erbt und beliebig erweitern kann (keine Mehrfachvererbung).


• Automatische Speicherbereinigung (englisch garbage collection), die nicht durch den Programmierer beeinflusst 

werden muss. Ein Objekt 'lebt' solange, wie es von anderen Objekten referenziert wird. 

• Smalltalkprogramme werden in Bytecode übersetzt, der durch eine virtuelle Maschine ausgeführt wird. Dadurch 

laufen Smalltalk-Programme ohne jegliche Änderung auf jedem System, für das eine virtuelle Maschine existiert. 

Ursprünglich wurde der Bytecode interpretiert; kommerzielle Umgebungen arbeiten inzwischen fast 

ausschließlich mit dynamischer Übersetzung. 

• Üblicherweise hat man eine Programmierumgebung (selbst in Smalltalk geschrieben), in der man Quelltext am 

„lebenden“ Objekt ändern und dann auch direkt in der geänderten Form (weiter)ausführen kann. 

„Smalltalkprogramme“ kann man ändern, während sie laufen. 

• Die Quelltexteingabe erfolgt üblicherweise im Klassenbrowser. Moderne RefactoringBrowser setzen sich 

allmählich gegen einfache Klassenbrowser durch, weil sie automatisierte Refactoring-Funktionen unterstützen 

und damit die Produktivität nochmals erheblich steigern, ähnlich wie sich das in der Java-Welt mit Eclipse 

etabliert hat. 

• Eine überraschende Eigenschaft im Vergleich zu traditionellen Sprachen ist, dass die Kontrollstrukturen wie 

if-then-else, for, while nicht in die Sprache eingebaut sind. Zumindest erscheint dies dem Programmierer so. Zum 

Beispiel wird eine IF-Anweisung so ausgeführt, indem eine ifTrue:-Botschaft an ein Boolesches Objekt gesandt 

wird. Als Parameter wird ein Block (Anweisungsfolge) übergeben. Lediglich in der Klasse True wird dieser 

Block ausgeführt. In der Klasse False ist diese Methode zwar auch implementiert, aber sie führt den Block nicht 

aus. 

Es gibt nur drei eingebaute ausführbare Konstrukte: 

• Senden einer Botschaft an ein Objekt 

• Zuweisen eines Objekts an eine Variable 

• Ein Objekt als Rückgabewert einer Methode liefern 

Geschichte und Bedeutung von Smalltalk 

1970–1980 

In diese Zeit fällt die Entwicklung der ersten Versionen von Smalltalk-71, Smalltalk-72, Smalltalk-74 und 

Smalltalk-76 [1] bis hin zum heute verbreiteten Standard Smalltalk-80 am Forschungszentrum Xerox PARC. 

1980–1990 

Die Programmierung mit Klassenbrowser und die Verwendung einer virtuellen Maschine zur Ausführung stellte von 

Anfang an gewisse Mindestanforderungen an die Hardware. Dies geschah zu einer Zeit in der die erschwinglichen 

Computer nicht über graphische Benutzeroberflächen verfügten und die Rechenleistung nicht für eine solche 

ausreichte. Smalltalk war seiner Zeit voraus und konnte zu Beginn nur auf Workstations effektiv eingesetzt werden. 

Im Ergebnis gab es daher nur wenige Smalltalk-Entwickler – dafür umso mehr C-Programmierer. Mit dem 

Aufkommen der graphischen Benutzeroberflächen im Mikrocomputerbereich entstand das objektorientierte C++ und 

da die meisten Entwickler C bereits kannten, konnte sich C++ sehr schnell verbreiten und Smalltalk blieb eine 

Randerscheinung. Zudem geschah dies in einer Zeit, in der Performance sehr wichtig war und Smalltalk auf hohe 

Ausführungsgeschwindigkeiten keinen besonderen Wert legte (Alan Kay: „It's still fast enough for our neurons“).


1990–2000 

Anfang und Mitte der Neunziger Jahre wurde Smalltalk in vielen Bereichen populär, in denen es auf die 

Beherrschung von Komplexität ankam (z. B. bei Expertensystemen). Verschiedene große Anbieter wie IBM 

begannen, Smalltalk stark zu unterstützen und in Großkundenprojekten einzusetzen. Es gab eine sprunghafte 

Zunahme verschiedener Implementierungen von Smalltalk. Mit dem Internet-Boom und dem davon profitierendem 

Java, büßte Smalltalk Ende der 90er Jahre seine gerade aufkommende Popularität jedoch wieder ein. 

In Java wurden einige Konzepte von Smalltalk (wie z.B. die Virtuelle Maschine und der Garbage Collector) 

übernommen. Die Syntax war jedoch wieder an C angelehnt. Auch kamen erneut traditionelle Mittel zum Einsatz, 

wie die Vermischung der Objektorientierung mit einfachen Datentypen und imperative Strukturen, geringe 

Selbstbezüglichkeit und der Edit-Compile-Test-Debug-Zyklus mit Quellcode als reiner Textdatei etc. Java dafür bot 

Normierung, Aufstiegspfade für C-Programmierer und nicht zuletzt Allianzmöglichkeiten gegen die 

MS-Windows-Dominanz. Zudem wurde es von Sun kostenlos zur Verfügung gestellt. 

Das Ende des kurzen Smalltalk-Booms wurde durch den Niedergang der Firma ParcPlace unterstrichen, die als 

Ausgründung des Xerox PARC mit VisualWorks (heute bei Cincom) den direkten Nachfolger der 

Originalimplementierung anbot, der die damals mächtigste Smalltalk-Entwicklungsumgebung darstellte: Mit 

VisualWorks geschaffene Anwendungen liefen bereits 1991 bitkompatibel (durch VM) auf Windows, Mac OS, 

Solaris (und anderen UNIX-Systemen) und konnte ab 1994 deren verschiedene Benutzeroberflächen mit „Camelon 

View“ unabhängig vom Laufzeitsystem simulieren. 

Die aufkommende Dominanz von Microsoft Windows entwertete jedoch diese und andere interessante 

Eigenschaften, da sich die Frage nach der Plattformunabhängigkeit dadurch für immer weniger Anwender stellte. 

Die Wettbewerber von Microsoft suchten stattdessen nach Mitteln, die MS Windows Dominanz zurückzudrängen. 

Nachdem sich bedeutende Firmen wie IBM und Sun für Java entschieden und dafür Marketing betrieben, gewannen 

Java und C++ klar die Oberhand bezüglich kommerzieller Unterstützung, was zur heutigen Situation führte. 

Obwohl Smalltalk sehr leicht zu erlernen (nur wenige Sprachkonstrukte) und zu debuggen ist (selten ist eine 

zeitaufwändige explizite Neukompilierung und -erstellung sowie ein Neustart des Programms erforderlich) und das 

Performanceproblem – zum Teil durch effektivere Implementierungen, zum Teil durch leistungsfähigere Hardware 

– inzwischen gelöst ist, wird Smalltalk heute noch immer in wenigen Bereichen eingesetzt. Einer der Gründe hierfür 

kann in der mangelnden Einheitlichkeit der Programmbibliotheken verschiedener Implementationen gesehen 

werden, von denen bisher keine eine „natürliche Dominanz“ (wie die von Sun für Java) entwickelt hat. 

Nachdem ParcPlace als Player ausgeschieden war, IBM sein Smalltalk-Engagement zugunsten von Java eingestellt 

hatte und verschiedenen zunächst erfolgsversprechende Smalltalk-Implementationen eingestellt wurden (z.B. 

Dolphin Smalltalk [2] ), gab es nur noch wenige überzeugte Anhänger, die an einen großen Durchbruch glaubten. 

Smalltalk blieb weiter ein Insiderthema. 

2000–2009 

In den letzten Jahren gibt es mit der Etablierung von freien Implementierungen eine Art „Renaissance“ von 

Smalltalk. Insbesondere das von ursprünglichen Smalltalk-Erfindern entwickelte plattformübergreifende Squeak und 

das darauf aufbauende Croquet erhalten wachsende Unterstützung aus Wissenschaft, IT-Industrie und einer großen 

freien Entwicklergemeinschaft. Squeak wurde erstmals im September 1996 als erstes freies Smalltalk veröffentlicht. 

Dan Ingalls, Ted Kaehler, John Maloney, Scott Wallace und Alan Kay schreiben, dass hier, was 1980 fehlschlug, 

geglückt sei. [3] 

Alan Kays Konzept einer interaktiven, computer- und netzwerkvermittelten Interaktion, das Dynabook, ist 

Bestandteil in der Softwareentwicklung für das One Laptop per Child-Projekt. [4] Standardmäßig werden auf den 

Schülerlaptops EToys, auf Squeak basierende Bausteine, installiert.


Mit Croquet wird, mit dem Hintergrund des heutigen Wissensstands, erneut eine Antwort auf die generelle Frage 

nach der optimalen Computer-Mensch-Schnittstelle gesucht. In den 80er Jahren war dies die – erstmals mit 

Smalltalk implementierte – zweidimensionale graphische Benutzeroberfläche, die ihre Verbreitung durch Apple und 

Microsoft fand. Heute sehen Alan Kay und andere darin eine dreidimensionale, plattformunabhängige, vernetzte 

Multibenutzerumgebung, in der Objekte fließend zwischen den verschiedenen teilnehmenden Rechnern ausgetauscht 

werden können. Die dazu notwendigen Eigenschaften besitzt nach Auffassung der Mitglieder des 2001 gestarteten 

und 2007 veröffentlichten Croquet-Projektes speziell Squeak Smalltalk, welches das ursprünglich zur 

Implementierung vorgesehene Java daher ersetzte. 

In 2009 ist das Pharo Project gestartet, das auf der Basis von Squeak eine freie, stabile Smalltalk-Plattform bietet, um 

weitere Anwendungsbereiche mit freiem Smalltalk zu erreichen. Ende 2009 wird VisualWorks 7.7 veröffentlicht, die 

inzwischen 9. Aktualisierung seit der Übernahme durch Cincom. 

Typisierte Variante von Smalltalk 

Smalltalk verfügt nicht über ein statisches Typsystem. Insbesondere findet man dort keine Typdefinitionen und 

Typannotationen an Variablen oder für die Ein-/Ausgabeparameter von Methoden. Demgemäß finden auch keinerlei 

Typprüfungen bei Wertzuweisungen statt, wie dies für typisierte Sprachen üblich ist, und zwar weder dynamisch 

(zur Laufzeit) noch statisch (zur Übersetzungszeit). Die Klassenhierarchie von Smalltalk darf nicht mit einer 

Subtypenhierarchie verwechselt werden - auch wenn moderne objektorientierte Programmiersprachen oftmals Typ- 

und Klassendefinitionen als einen einzigen Vorgang betrachten, handelt es sich hier um unterschiedliche Konzepte 

und auch unterschiedliche Komponenten des Übersetzers und des Laufzeitsystems einer Sprache. Smalltalk verfügt 

hinsichtlich der Bildung und Prüfung von Typen über keine solche Komponente. 

Es gibt allerdings Varianten von Smalltalk, die über ein statisches Typsystem verfügen, so etwa Strongtalk. 

Strongtalk ermöglicht die klassenunabhängige Definition von Typen in einer eigenen Typhierarchie und in der Folge 

auch die Annotation solcher Typen an Variablen und Methoden. 

Ausdrücke (Expressions) 

Ausdrücke haben folgende Form: 

objekt nachricht 

Das heißt man sendet einem Objekt eine Nachricht. Das Objekt antwortet mit einem Antwortobjekt. Ausdrücke 

müssen mit einem Punkt getrennt werden. 

Es gibt drei Arten von Nachrichten, unäre Nachrichten, binäre Nachrichten und Schlüsselwort-Nachrichten. 

Unäre Nachrichten haben keinen Parameter und bestehen aus einem Bezeichner: 

objekt nachricht 

Eine binäre Nachricht hat genau einen Parameter und besteht aus einem oder mehreren Sonderzeichen. Vier 

Beispiele: 

1 + 3 

100 @ 200 

vorname , nachname 

10 // 3 

Die meisten arithmetischen Operationen sind in Smalltalk als binäre Nachrichten implementiert. 

Eine Schlüsselwort-Nachricht hat eine oder mehrere Parameter, wobei vor den Parametern Doppelpunkte stehen. 

objekt nachricht: parameter


Diese Schlüsselwort-Nachricht heißt nachricht: und hat einen Parameter parameter. 

objekt nachricht: parameter1 nachricht: parameter2 

Diese Schlüsselwort-Nachricht heißt nachricht:nachricht: und hat zwei Parameter. D. h. Parameter können bei 

Schlüsselwort-Nachrichten mitten in die Nachricht eingefügt werden. Diese Besonderheit macht es möglich, in 

Smalltalk besonders leicht lesbare Programme zu schreiben: 

collection copyFrom: 1 to: 10 

Das klingt wie ein Satz. In Java würde man das folgendermaßen schreiben: 

collection.copyFromTo(1, 10); 

Ausdrücke können kombiniert und mit Klammern geschachtelt werden. Ohne Klammern werden Ausdrücke in 

folgender Reihenfolge ausgeführt: Unäre Nachrichten vor binären Nachrichten vor Schlüsselwort-Nachrichten. Bei 

"gleichrangigen" Nachrichten erfolgt die Auswertung von links nach rechts. 

Sollen einem Objekt in Folge mehrere Nachrichten geschickt werden, besteht die Möglichkeit, diese Nachrichten mit 

einem Semikolon (;) zu verketten: 

objekt 

nachricht1; 

nachricht2; 

nachricht3 

Zuweisungen 

Eine Zuweisung hat folgende Form: 

variable := ausdruck 

Blöcke 

Blöcke sind Sequenzen von Zuweisungsanweisungen und Expressions. Sie werden durch eckige Klammern 

eingeschlossen. Blöcke können parameterlos sein oder auch Parameter aufweisen. 

blockEins := [ Anweisungen ] 

blockZwei := [ :einParameter | Transcript show: einParameter ] 

Blöcke behalten ihren Kontext, so dass sie bei der Ausführung mit den Objekten arbeiten, die dort bei der Erzeugung 

verfügbar waren. Um einen Block ohne Parameter auszuführen gibt es eine parameterlose Methode. Bei dem Aufruf 

von Blöcken mit Parametern müssen diese mit Werten versorgt werden. 

blockEins value 

blockZwei value: 'Test'



Die Kontrollstrukturen werden mit booleschen Ausdrücken und Blöcken implementiert. Ein boolescher Ausdruck 

liefert nach der Auswertung ein Boolesches Objekt. Diesem wird dann eine Message zugesandt, die als Parameter 

einen ausführbaren Block hat. Der Programmtext sieht aber ähnlich aus, wie bei anderen Programmiersprachen auch, 

so dass man wie dort einfach gewisse Kontrollstrukturen als gegeben anwenden kann. 

Einige Beispiele. 

IF-Anweisung 

oder 

aBoolean ifTrue: [ "ein Block mit Anweisungen" ] 

( einAusdruck ) ifTrue: [ "ein Block mit Anweisungen" ] 

Das aus anderen Programmiersprachen bekannte else sähe folgendermaßen aus: 

aBoolean ifTrue: [ ... ] ifFalse: [ ... ] 

Schleifen 

10 timesRepeat: [ Transcript show: '.' ]. 

1 to: 10 do: [ :i | Transcript show: i printString ]. 

[ "ein Block, der ein boole'sches Objekt zurückgibt" ] whileTrue. 

[ "ein Block, der ein boole'sches Objekt zurückgibt" ] whileFalse. 

[ "ein Block, der ein boole'sches Objekt zurückgibt" ] whileTrue: [ 

"Block mit Schleifenrumpf" ]. 

[ "ein Block, der ein boole'sches Objekt zurückgibt" ] whileFalse: [ 

"Block mit Schleifenrumpf" ] 

Collections 

Die Smalltalkumgebungen sind mit einer großen Klassenbibliothek ausgestattet. Ein wichtiger allgemeiner 

Objekttyp (Klasse) sind die Collections, d. h. Sammlungen von Objekten. Die Klasse Collection steht an der Wurzel 

einer ganzen Hierarchie von Klassen. 

Eine wichtige Arbeit, die man mit einem Collection-Objekt durchführen kann, ist für jedes Element der Collection 

einen Block von Anweisungen auszuführen. Andere Programmiersprachen brauchen hierfür spezielle Konstrukte 

(Iteratoren). 

aCollection do: [ :einElement | einElement 

auszuführendeArbeitFürDiesesElement ] 

Es hat sich eingebürgert, den Parameter als each zu bezeichnen, so dass direkt klar ist was hierbei gemeint ist. Bei 

Verwendung von mehreren Collections sollte man dem noch eine genaue Bezeichnung nachsetzten. Iteriert man 

bspw. über alle x und y Werte aus zwei unterschiedlichen Collections: 

xWerte do: [:eachX | yWerte do: [:eachY | map addPoint: eachX withY: 

eachY]]



Das klassische HelloWorld-Beispiel sieht wie folgt aus: 

Transcript show: 'Hello World!'. 

Transcript ist eine in jeder Smalltalkumgebung vordefinierte globale Variable, die ein Objekt enthält, auf dem man 

Dinge protokollieren kann (ein Ausgabefenster). 

Wir senden diesem Objekt die Message 

show: aString 

Ein bereits etwas komplexeres Beispiel: 

'Hello World' do: [ :eachChar| 

]. 

Transcript show: eachChar ; cr. 

gibt den Text „Hello World“ vertikal aus. 'Hello World' ist ein String (Zeichenkette). Die Klasse dieses Objektes ist 

eine Unterklasse von Collection. Ein String ist also eine Collection (= Sammlung) von Zeichen. Indem wir dem 

Objekt String die Message 

aString do: [ :eachChar | OperationenMitDiesemBuchstaben ] 

senden, gehen wir alle Buchstaben (Elemente) des Strings einzeln durch. 

Das Dictionary (in Perl Hash, in Java HashMap) ist eine in Smalltalk häufig verwendete Datenstruktur: 

d := Dictionary new. 

d at: 'grün' put: 'green'. 

d at: 'blau' put: 'blue'. 

d at: 'rot' put: 'red'. 

Transcript show: (d at: 'blau'). 

Alternativ können die Nachrichten auch wie bereits beschrieben verkettet werden: 

d := Dictionary new. 

d at: 'grün' put: 'green'; 

at: 'blau' put: 'blue'; 

at: 'rot' put: 'red'. 

Transcript show: (d at: 'blau'). 

Auch das Dictionary ist eine Unterklasse von Collection. Diese Datenstruktur entspricht dem assoziativen Array in 

anderen Programmiersprachen.


Schreibweise 

Smalltalk wird mit kleinem T geschrieben. Häufig findet sich die falsche Schreibweise SmallTalk, selbst auf den 

offiziellen IBM-Webseiten (allerdings nicht durchgehend). Der Fehler rührt möglicherweise daher, dass 

zusammengesetzte Namen in Smalltalk selbst durch Binnenmajuskel strukturiert werden. 

Literatur 

• Adele Goldberg: Smalltalk-80, The Interactive Programming Environment. Addison-Wesley, 1983, ISBN 

0201113724 

• Glen Krasner: Smalltalk-80, Bits of History, Words of Advice. Addison-Wesley, 1. August 1983, ISBN 

0-201-11669-3 

• Johannes Brauer: Grundkurs Smalltalk · Objektorientierung von Anfang an. Eine Einführung in die 

Programmierung Vieweg-Verlag, 3. Auflage 2009, ISBN 3834807125 

• Sherman R. Alpert, Kyle Brown, Bobby Woolf: The Design Patterns Smalltalk Companion. Addison-Wesley 

Professional, 10. Februar 1998, ISBN 0201184621 

• Mark J. Guzdial: Squeak: Object-Oriented Design with Multimedia Applications. Prentice Hall, 20. Dezember 

2000, ISBN 0130280283 

• Mark J. Guzdial, Kimberly M. Rose: Squeak: Open Personal Computing and Multimedia. Prentice Hall, 2. 

August 2001, ISBN 0130280917 

• Simon Lewis: The Art and Science of Smalltalk. Prentice Hall, 1. März 1995, ISBN 0133713458 

• Günther Vinek: Objektorientierte Softwareentwicklung mit Smalltalk. Springer Verlag, 24. April 1997, ISBN 

978-3-540-62558-2 

• Smalltalk-Bücher als PDF-Dokumente zum Herunterladen [5] 

Weblinks 

• German Smalltalk Users Group [6] z.B. aktiv im Frankfurter und Münchner Raum 

• STIC [7] ist die Hersteller-unabhängige Lobby Organisation (Juni 2007) 

• Smalltalk Solutions [8] Jährliche Konferenz zu Smalltalk 

• Smalltalk link fountain [9] weitere Links zu Smalltalk 

• Dolphin Map · Ein Wiki mit Dolphin Smalltalk spezifischen Informationen [10] 

• Vortrag von Alan Kay [11] auf der O'Reilly Etech 2003 Presentation 


• Ambrai Smalltalk [12] – Smalltalk für Mac OS X. 

• Cincom Smalltalk [13] – Smalltalk-Dialekt der Firma Cincom [14] . Angeboten werden folgende Umgebungen: 

• ObjectStudio [15] – Entwicklungsumgebung für Microsoft Windows mit COM- und ODBC-Schnittstellen. 

• VisualWorks [16] für verschiedene Plattformen. Es ist auch eine kostenlose Version für den unkommerziellen 

Einsatz verfügbar. 

• Croquet – Freie Implementierung u.a. von Smalltalk Miterfinder Alan Kay als zukunftsorientierte 

Anwenderoberfläche die netzbasiert, dreidimensional, mehrbenutzerfähig, dezentral, multimedial und 

plattformübergreifend ist. Das Croquet Consortium [17] wird von führenden wissenschaftlichen Instituten und 

Unternehmen unterstützt. 

• Dolphin Smalltalk [18] – windowsbasierte Smalltalk-Umgebung (eingestellt?). 

• GNU Smalltalk [19] – freies Smalltalk des GNU-Projekts. 

• LittleSmalltalk [20] – freie Implementierung basierend auf Timothy A. Budds Ideen. 

• LSW Vision-Smalltalk [21]


• StepTalk – GNUstep und Mac OS X Scripting-Framework. 

• Squeak – freie plattformunabhängige Implementierung von Smalltalk-80-Erfindern wie Alan Kay und Dan 

Ingalls mit multimedialen Elementen und großer aktiver Unterstützergemeinde. 

• Pharo [22] - ein stabile Variante von Squeak 

• Syx [23] – eine weitere freie Smalltalk-Implementierung. 

• Smalltalk/X [24] – Smalltalk der Firma eXept Software AG (kostenlos verfügbar, auch für kommerzielle 

Projekte). 

• Smalltalk MT bei Object Connect [25] oder Smalltalk MT bei Genify [26] – ein C++-nahes Smalltalk-Derivat (C++ 

mit Smalltalk-Syntax), das zu nativen Code kompiliert. 

• Strongtalk [27] – freie (open source) Smalltalk-Implementierung für Microsoft Windows mit besonderem 

Augenmerk auf Performance und optionaler starker Typisierung. 

• VisualAge for Smalltalk [28] – Smalltalk-Umgebung von IBM (eingestellt, der Nachfolger ist VAST [29] ). 

Siehe auch 

• Objective-C 

• Self (Programmiersprache) 

• Slate (Programmiersprache) 

• Strongtalk 

• Squeak 

• Scratch (Programmiersprache) 

Referenzen 

[1] Vgl. Kay, Alan C. (1993), »The early history of Smalltalk«, in: »ACM SIGPLAN notices« (Tagungsjournal), Bd. 28, No. 3, März, 

Association for Computing Machinery, New York, S. 69 ff. – PDF: 2004-0924-2355 (1999-0802-2121) (http:/ / www. smalltalk. org/ 

downloads/ papers/ SmalltalkHistoryHOPL. pdf). 

[2] http:/ / www. object-arts. com/ content/ navigation/ home. html 

[3] Back to the Future: The Story of Squeak (http:/ / users. ipa. net/ ~dwighth/ squeak/ oopsla_squeak. html) 

[4] Windleys Technometria, 23. Februar 2006: Alan Kay: The $100 Laptop and Powerful Ideas (http:/ / www. windley. com/ archives/ 2006/ 02/ 

alan_kay_the_10. shtml) 

[5] http:/ / stephane. ducasse. free. fr/ FreeBooks. html 

[6] http:/ / swiki. gsug. org/ 

[7] http:/ / www. stic. st/ 

[8] http:/ / www. smalltalksolutions. com/ 

[9] http:/ / www. mars. dti. ne. jp/ %7Eumejava/ smalltalk/ stLinks/ stLinks. html 

[10] http:/ / www. dolphinmap. net 

[11] http:/ / www. lisarein. com/ alankay/ tour. html 

[12] http:/ / www. ambrai. com/ 

[13] http:/ / smalltalk. cincom. com/ index. ssp 

[14] http:/ / www. cincom. com 

[15] http:/ / smalltalk. cincom. com/ prodinformation/ index. ssp?content=osfactsheet 

[16] http:/ / smalltalk. cincom. com/ prodinformation/ index. ssp?content=vwfactsheet 

[17] http:/ / www. croquetconsortium. org 

[18] http:/ / www. object-arts. com/ 

[19] http:/ / directory. fsf. org/ smalltalk. html 

[20] http:/ / www. littlesmalltalk. org/ 

[21] http:/ / www. lesser-software. com/ lswvst. htm 

[22] http:/ / www. pharo-project. org/ home 

[23] http:/ / code. google. com/ p/ syx/ 

[24] http:/ / www. smalltalk-x. de 

[25] http:/ / www. objectconnect. com/ 

[26] http:/ / www. genify. com 

[27] http:/ / www. strongtalk. org/


[28] http:/ / www-4. ibm. com/ software/ ad/ smalltalk/ 

[29] http:/ / www. instantiations. com/ VAST/ 

Turbo Pascal 

Turbo Pascal ist eine integrierte Entwicklungsumgebung der Firma Borland für die Programmiersprache Pascal. 

Die Anfänge 

Der Compiler basierte auf dem Blue Label Pascal Compiler, der von Anders Hejlsberg ursprünglich für das 

Kassetten-basierte Betriebssystem NasSys des Mikrocomputers Nascom entwickelt wurde. Dieser Compiler wurde 

zunächst als Compass Pascal Compiler für das Betriebssystem CP/M und dann als Turbo Pascal Compiler für 

MS-DOS und CP/M weiterentwickelt. 

Turbo Pascal 1.0 

Die erste Version von Turbo Pascal erschien im 

November 1983, zu einer Zeit, als das Konzept der 

integrierten Entwicklungsumgebungen noch recht neu 

war. Ein Programmierer hatte zu dieser Zeit auf einem 

IBM-kompatiblen PC im Wesentlichen die Wahl 

zwischen dem mit DOS mitgelieferten Microsoft 

BASIC-Interpreter oder einem professionellen und 

teuren BASIC-, C-, Fortran- oder Pascal-Compiler 

(UCSD). Die Compiler waren eher umständlich zu 

benutzen: Mangels Multitasking unter MS-DOS 

Turbo Pascal 1.0 aus dem Jahr 1983 

bestand jeder Testlauf aus dem Verlassen, Starten und Neuladen der verschiedenen Tools (Editor, Compiler, Linker, 

Debugger), die für die Softwareentwicklung notwendig sind. Da die meisten PCs zu dieser Zeit keine Festplatten 

hatten (eine solche kostete zum damaligen Zeitpunkt 2000 US-Dollar und mehr), musste oft sogar noch mehrmals 

die Diskette gewechselt werden. 

In diese Situation hinein kam Turbo Pascal mit dem IDE-Konzept, das die verschiedenen Tools in einem Programm 

vereinte. Es war zudem gerade einmal rund 60 KB groß und lief damit auf jedem damaligen PC in hoher 

Geschwindigkeit. Selbst auf einem PC mit nur einem Diskettenlaufwerk konnte auf Diskettenwechsel verzichtet 

werden, da auf der Turbo-Pascal-Diskette noch genug Platz für das gerade bearbeitete eigene Programm war. 

Schließlich war das System preislich selbst für Schüler und Studenten erschwinglich – mit dem Ergebnis, dass es im 

Laufe der 1980er Jahre auf dem PC zum Quasistandard wurde. 

Folgeversionen 

Ohne Turbo Pascal hätte die Sprache Pascal sicher das gleiche Schicksal ereilt wie viele an Universitäten vorher und 

nachher geborene „Kunstsprachen“, z. B. Prolog, Modula-2 oder Oberon (die letzten beiden auch von Niklaus 

Wirth), die heute praktisch verschwunden sind. Hejlsberg entwickelte die Sprache und das System pragmatisch 

weiter: Von Anfang an wurde die Laufzeitbibliothek um Routinen ergänzt, die Zugriff auf das System ermöglichten 

– ganz entgegen dem ursprünglichen Konzept von Wirth. Dabei wurde – anders als z. B. bei der Sprache C – die für 

Pascal typische strenge Typprüfung etc. beibehalten (beides hat Vor- und Nachteile: Eine strenge Prüfung 

vermindert die Gefahr ungewollten Fehlverhaltens eines Programms, macht den Quelltext aber meist länger und 

zwingt dazu, bewusst Funktionen zur Typumwandlung zu nutzen). Je umfangreicher ein Programmpaket wird, desto


wichtiger werden solche Funktionen, weshalb auch andere Programmiersprachen z. B. C++ diese Konzepte 

übernommen haben. 

• In Version 3 (September 1986) kam in der MS-DOS-Version Grafik dazu. Dies war die letzte Version, die auch 

noch für CP/M erschien, allerdings ohne die Grafikmöglichkeiten, da die meisten CP/M-Rechner nicht 

grafikfähig sind. Es gab drei unterschiedliche Versionen für MS-DOS, die es ermöglichten, unterschiedlichen 

Code zu generieren, und zwar für emulierten Fließpunkt-Code, Coprozessor-orientierten Code, und BCD-Code. 

• In Version 4 (Dezember 1987) kam das Unit-Konzept dazu, das Bibliotheken und große Projekte ermöglichte. 

Das Einfügen von Assemblerteilen in den Quelltext wurde mit Inline-Codes unterstützt. 

• In Version 5 (Oktober 1988) wurde der Debugger in die Entwicklungsumgebung integriert. Damit wurde es 

möglich, innerhalb der IDE zu debuggen, Haltepunkte zu setzen und Variablenwerte zu beobachten. 

• In Version 5.5 (Mai 1989) kam die Objektorientierung hinzu. 

• In Version 6 (November 1990) kam eine objektorientierte 

GUI-Bibliothek hinzu (Turbo Vision), ähnlich der späteren MFC für 

Windows; Turbo Vision war für den Textmodus des PCs konzipiert, 

enthielt aber bereits Steuerelemente wie Fenster, 

Befehlsschaltflächen und Bildlaufleisten, die durch Textsymbole 

dargestellt wurden. Außerdem konnten (auch umfangreichere) 

Assemblerfunktionen in Intelsyntax direkt im Quelltext realisiert 

werden. Die Entwicklungsumgebung wurde entsprechend erweitert, 

so dass auch Assemblerteile im Einzelschrittmodus bei 

gleichzeitiger Kontrolle aller Flag- und Registerinhalte ausgeführt werden konnten. 

Version 6.0 von 1990 

(im Turbo-Vision-Stil) 

• Parallel zu Version 6 kam Turbo Pascal für Windows 1.0 auf den Markt, dessen GUI komplett als 

Windows-Anwendung ausgelegt war und das in Version 7 (Borland Pascal) übernommen und ausgebaut wurde. 

• In Version 7 (Oktober 1992) wurde in der professionellen Variante (Borland Pascal) die Entwicklung von 

Protected-Mode-Anwendungen innerhalb der IDE möglich – allerdings ohne integrierten Debugger. Im April 

1993 folgte noch eine nachgeschobene/fehlerbereinigte Version 7.01; dies war zugleich auch die letzte von 

Borland veröffentlichte Pascal-Version. 

Anfang der 1990er-Jahre wurde Turbo Pascal auf Windows portiert. Dies war allerdings eine Sackgasse. Die 

Programmierung war unter Turbo Pascal für Windows ähnlich aufwendig wie in C – mit dem zusätzlichen Nachteil, 

dass Windows selbst in C programmiert ist, weshalb die Schnittstellen zwischen Windows und Pascalprogramm 

mindestens grundlegende C-Kenntnisse erfordern. Borland adaptierte in der Folgezeit das 

Rapid-Application-Development-Prinzip, das sich vorher schon bei Visual Basic von Microsoft sehr bewährt hatte: 

Die grafischen Elemente einer Windows-Anwendung werden mit der Maus zusammengestellt, der zugehörige Code 

wird automatisch erzeugt. Dieses Produkt wurde Delphi genannt, die zugrundeliegende Sprache ist Object Pascal 

von Borland. 

Ausschnitt der Anweisungen 

begin – Beginn eines Anweisungsblockes 

uses crt; – Einbinden der Bibliothek CRT(zur Textein- und -ausgabe) in den Suchpfad 

var a, b, c: string; – Variablendeklaration 

Writeln ('Text'); – Ausgabe von "Text" 

Readln (text); – Lese Eingabe und speichere diese in die Variable text 

ClrScr; – Löscht den Bildschirminhalt. (Benötigt 'uses crt;') 

Textcolor (1); – Setzt die Textfarbe 0-15, 16-31 blinkender Text (Benötigt 'uses crt;') 

Textbackground (1); – Setzt die Hintergrundfarbe 0-15 (Benötigt 'uses crt;') 

GoToXY(X,Y); - Geht zu Textstelle X/Y (Benötigt 'uses crt;')


Sound (x); – Spielt Ton von x Hertz ab 

Delay (x); – Programmverzögerung von x ms 

Nosound; – Stoppt die Tonausgabe 

if a = 'x' then x – Bedingungsanweisung 

end; – Ende eines Anweisungsblocks 

end. – Programmende 

writeln(zahl:10:2); -Ausgabeformatierung, Ausgabe auf 10 Ziffern und 2 Nachkommastellen von zahl 

Siehe auch 

• Mit Free Pascal und GNU Pascal gibt es zwei Turbo-Pascal-kompatible freie Compiler, die für zahlreiche 

Betriebssysteme zur Verfügung stehen. Die Entwicklung von Virtual Pascal wurde hingegen eingestellt, obwohl 

es noch eine große Gemeinschaft gibt. 

Literatur 

• Michael Starke: Borland Pascal 7.0. Das Buch. TLC The Learning Companie 1993, ISBN 978-3893622887. 

• Karl-Hermann Rollke: Das Borland Pascal 7.0 Buch. Sybex-Verlag GmbH, ISBN 1995, 978-3815500712 

• Reiner Schölles: Das große Buch zu Turbo und Borland PASCAL 7.0 Data Becker GmbH + Co. Kg 1994, ISBN 

978-3890115887 

• Irene Bauder, Jürgen Bär: Borland Pascal 7.0. Das Kompendium. Einführung. Arbeitsbuch. Nachschlagewerk. 

Pearson Education 1998, ISBN 978-3877914502 

Weblinks 

• Im „Museum“ des Borland Developer Network [1] kann man die Versionen 1.0, 3.02 und 5.5 von Turbo Pascal 

(nur für MS-DOS) kostenlos und legal herunterladen. 

• Die Firma TMT [2] bietet ebenfalls Turbo-Pascal-Klone für 32-Bit-Systeme an, eine abgespeckte Variante ist 

kostenlos. 

• Bei Webplain.de [3] trifft sich die aktivste deutschsprachige Turbo-Pascal-Anhängerschaft. 

• Paswiki [4] Wiki über Turbo Pascal. 

• Viele weitere Informationen und Ressourcen zu Turbo Pascal finden sich auf der Turbo Pascal Programmers Page 

[5] . 

• Die Geschichte von Turbo Pascal / Delphi [6] 

Referenzen 

[1] http:/ / bdn. borland. com/ museum 

[2] http:/ / www. frameworkpascal. com/ 

[3] http:/ / www. webplain. de 

[4] http:/ / www. paswiki. de 

[5] http:/ / www. devq. net/ pascal/ 

[6] http:/ / www. bernd-leitenberger. de/ turbo-pascal-history. shtml


Visual Basic 

Visual Basic .NET 

Basisdaten 

Paradigmen: prozedural, vollständig objektorientiert 


Entwickler: Microsoft Corp. 

Aktuelle Version: 9.0.21022.8 (16. November 2007) 

Typisierung: stark, explizit (auf Wunsch auch implizit), statisch 

wichtige Implementierungen: Microsoft Visual Basic .NET, SharpDevelop 

Einflüsse: Visual Basic Classic, Java, C# 



msdn.microsoft.com/de-de/vbasic/ [1] 

Visual Basic (Abk. VB) ist eine proprietäre objektorientierte Programmiersprache, deren neuere Versionen auf dem 

Microsoft .NET-Framework basieren. Um zwischen den alten nicht vollständig objektorientierten und den neuen auf 

dem .NET-Framework basierenden Versionen zu unterscheiden, werden erstere bis inklusive Visual Basic 6.0 als 

Visual Basic Classic, die letzteren hingegen als Visual Basic .NET (Abk. VB.NET) bezeichnet. 

Einführung 

Der historisch wichtigste Vorteil von Visual Basic ist die einfache Erlernbarkeit der Sprache. Die Sprache ist 

bewusst an die englische Sprache angelehnt und benutzt Wörter anstelle von Symbolen. Beispiele sind And statt &&, 

Or statt ||,, Mod statt %, wie in C++ üblich. Aus genau diesem Grund bevorzugen jedoch einige Programmierer C#, 

da der Leistungsumfang dem von VB.NET nahezu gleich ist, die Sprache jedoch teilweise kompaktere 

Formulierungen ermöglicht. 

Da Visual Basic von Anfang an zum Einsatz mit einer integrierten Entwicklungsumgebung konzipiert wurde, 

können Visual-Basic-Programme in der Regel mit geringem Zeitaufwand erstellt werden. Dadurch eignet es sich für 

Rapid Application Development. Visual Basic Classic, das noch nicht die objektorientierten Fähigkeiten von 

VB.NET hatte, wurde oft eingesetzt, um erste Prototypen für Programme zu bauen, die später z. B. in C++ 

implementiert wurden. 

Visual Basic gilt als sehr gut dokumentiert. Die MSDN Library, die die .NET-Architektur, die 

Standard-.NET-Sprachen, darunter Visual Basic .NET, sowie Visual Studio .NET dokumentiert und beschreibt, ist 

eine der größten (Auslieferung auf drei CDs / 1 DVD) Informationssammlungen für Programmierer. 

Visual Basic unterstützt sowohl statische als auch dynamische Typisierung über den Datentyp Object (bzw. 

„Variant“ in VB Classic).


Geschichte 

In den frühen 1990ern hatte BASIC, das damals zusammen mit vielen Betriebssystemen geliefert wurde, gegenüber 

anderen Hochsprachen wie C und C++ an Bedeutung verloren. BASIC bot eine viel eingeschränktere Funktionalität 

und Erweiterbarkeit, wodurch es für den professionellen Einsatz nicht geeignet war. 

Der spätere historische Erfolg von Visual Basic beruht vor allem auf der einfachen Erlernbarkeit, visuellen 

Entwicklungsumgebungen und der unkomplizierten Ausbaufähigkeit der zugehörigen Programmbibliotheken. 

Kritiker bemängeln die mangelhafte Funktionalität. Oft ist auch von langsamen Ausführungsgeschwindigkeiten bei 

leistungsschwachen Rechnern (meist nur während der Interpretation) die Rede, welche jedoch heute bei modernen 

Rechnern nach der Übersetzung vernachlässigbar ist. 

1991: Visual Basic 1 und Visual Basic für DOS – Die Anfänge 

Visual Basic Classic 

Paradigmen: prozedural, objekt- und ereignisorientiert 


Entwickler: Microsoft Corp. 


Typisierung: stark, statisch, implizit und explizit (auf Wunsch nur explizit) 

wichtige Implementierungen: Microsoft Visual Basic 

Dialekte: VBA, VBScript 

Einflüsse: QuickBasic 

Beeinflusste: Gambas 


MS DOS (nur Version 1) 


Die Firma Microsoft, deren Firmengeschichte mit der Entwicklung 

eines BASIC-Interpreters begann, verband im Jahre 1991 ihren 

QuickBasic-Compiler mit einer Umgebung zur interaktiven Gestaltung 

von Benutzeroberflächen. Diese Umgebung, die auf Alan Cooper 

(manchmal als „Vater“ von Visual Basic bezeichnet) zurückgeht, 

erlaubte es zum ersten Mal, schnell und einfach Anwendungen für 

Windows zu erstellen. 

Der Quellcode von Visual-Basic-1-Programmen wurde interpretiert, 

Der Formendesigner in Visual Basic for MS-DOS 

d. h. der Quellcode wurde während der Ausführung (also zur Laufzeit) abgearbeitet. Die mit der Übersetzung 

erzeugten Programmdateien (EXE-Datei) enthielten keinen direkt ausführbaren Maschinencode, sondern so 

genannten P-Code. Zur Ausführung musste deshalb stets eine separate Laufzeitbibliothek mitgeliefert werden. Dies 

gilt auch noch für die Versionen 5 und 6 von Visual Basic, die nativen Code erzeugen können.


Visual Basic für Windows kam vor Visual Basic für MS-DOS (Abk. 

„VBDOS“) auf dem Markt. VBDOS basierte stärker auf den 

Vorgängern Microsoft BASIC PDS bzw. QuickBASIC und konnte 

entsprechenden Quellcode unmittelbar verarbeiten. [2] VBDOS erzeugte 

Programme für den Ablauf unter DOS (und hierbei auch eigenständig 

ausführbare Dateien ohne eine zusätzliche Laufzeitbibliothek), nicht 

aber Windows-Programme. Während die Windows-Variante von 

Visual Basic eine grafische Benutzeroberfläche hatte und auch 

Bitmaps anzeigen konnte, lief VBDOS im Textmodus und bildete eine 

quasi-grafische Benutzeroberfläche aus ASCII-Zeichen nach. VBDOS 

war nicht so erfolgreich wie die Version für Windows, sodass es nie 

eine Nachfolgeversion gab. 

Mit Visual Basic wurde die Strategie der verschiedenen Ausführungen 

eingeführt. Vorher entsprach QuickBASIC der „Standard Edition“ und 

BASIC PDS der „Professional Edition“. Es waren Beispielprogramme 

enthalten, die zum Beispiel die Einbindung eines Hilfesystems, die 

Unterstützung von Windows-Schriftarten und die Verwendung von 

Präsentationsgrafiken demonstrierten. 

1992–1993: Visual Basic 2–3 – Integrierung des Entwicklungsprozesses 

IDE von VBDOS 

VBDOS Hilfedatei 

Mit den nur noch unter Windows erschienenen Folgeversionen „Visual Basic 2“ (1992) und „Visual Basic 3“ (1993) 

wurden vor allem Erweiterungen der Sprache und der Entwicklungsumgebung umgesetzt. Unter anderem wurden 

Objekte eingeführt. Ab Visual Basic 2 wurden außerdem so genannte Zusatzsteuerelemente (Controls) vom Typ 

VBX (Visual Basic Extensions) unterstützt, mit denen fremde Hersteller oder andere C-Programmierer die 

Funktionalität von Visual Basic erweitern konnten, und die ein wichtiger Faktor beim Erfolg von Visual Basic 

waren. 

1996–1998: Visual Basic 4–6 – 32 Bit und COM 

Das nach einer längeren Pause im Jahre 1996 veröffentlichte Visual Basic 4 gab es erstmals nicht nur in einer 

16-Bit-Version für Windows-Systeme bis Version 3.1, sondern auch als 32-Bit-Version, mit der man für Windows 

NT und Windows 95 optimierte Programme erstellen konnte. Dem Sprung von 16 auf 32 Bit folgte im 

darauffolgenden Jahr die nächste große Neuerung: Visual-Basic-5-Programme wurden erstmals in Maschinencode 

kompiliert. Damit war es – im Gegensatz zu den Vorgängerversionen – nicht mehr möglich, den Quelltext von 

Visual-Basic-Programmen aus der ausführbaren Datei zu extrahieren. Außerdem ergab sich ein erheblicher 

Performancegewinn. Durch diese Neuerungen eignete sich Visual Basic 5 erstmals auch zum Erstellen zeitkritischer 

Anwendungen. Trotzdem waren Visual-Basic-Programme immer noch langsamer als etwa C++-Programme. 

Mit Visual Basic 4, 5 und 6 (1998) wurden der Sprache objektorientierte Elemente hinzugefügt, jedoch ohne alle 

Kriterien der objektorientierten Programmierung zu erfüllen. Visual Basic 6 war dabei die letzte 

Visual-Basic-Version, die die Erstellung von nativen Win32-Programmen ermöglichte. 

Visual Basic 4 erweiterte das Konzept von „Standard Edition“ und „Professional Edition“ um die „Enterprise 

Edition“. Mit Visual Basic 5 wurde außerdem eine „Control Creation Edition“ (CCE) veröffentlicht, die zwar 

kostenlos war, jedoch prinzipiell nur zur Erstellung von Steuerelementen (ActiveX-Controls, OCX) genutzt werden 

konnte.


2002–2003: Visual Basic .NET 

Um die Jahrtausendwende hatte Visual Basic Vorsprung eingebüßt. Viele andere Hochsprachen boten nun auch die 

Möglichkeit, einfach Windows-Benutzeroberflächen zu erstellen, zum Beispiel C++ mit den Microsoft Foundation 

Classes (MFC). Doch schwererwiegend war sicher, dass sich VB inzwischen zu einem komplexen und eher 

inhomogenen Produkt entwickelt hatte, dessen Wartung und Verbesserung zunehmend schwieriger wurde. Wohl aus 

diesen Gründen stoppte Microsoft die Weiterentwicklung dieses Produktes (trotz des kommerziellen Erfolgs und des 

Protestes vieler VB-Programmierer) und integrierte die Programmiersprache Visual Basic in die hauseigene 

.NET-Architektur. Dabei wurde die Sprache zu einem hohen Grad verändert, um den Ansprüchen an eine 

.NET-Sprache zu genügen. Visual Basic .NET ist deshalb vollständig objektorientiert. Der Quellcode wird bei der 

Kompilierung nicht mehr in nativen Win32-Code übersetzt, sondern in Code der Common Intermediate Language, 

dem .NET-Pendant des Java-Bytecodes. Dieser Code wird zur Laufzeit in Maschinencode umgesetzt und kann an die 

aktuelle Plattform angepasst werden. 

Die Umstellung auf .NET-Technologie brachte neben diesen Änderungen im Hintergrund auch Änderungen für den 

Programmierer. Das .NET-Framework stellt zahlreiche Funktionsbibliotheken zur Verfügung, z. B. für Dateizugriffe 

oder zum Lesen und Schreiben von XML-Dateien. Am wichtigsten sind hier die Windows Forms, die das veraltete 

Thunder-Forms-System der vorherigen Versionen zur Erstellung von Benutzeroberflächen ablöst. Der 

augenscheinlichste Unterschied der Windows Forms gegenüber den Thunder Forms ist die Tatsache, dass kein 

spezielles Dateiformat mehr zur Speicherung verwendet wird, sondern die Formulare als Klassen durch Code erstellt 

werden. Dabei wird der Konstruktor der Fensterklasse verwendet, um die ebenfalls durch Klassen repräsentierten 

Steuerelemente zu erstellen. Moderne Integrierte Entwicklungsumgebungen ermöglichen die visuelle Erstellung von 

Formularen, wobei der für den Konstruktor der Fensterklasse notwendige Code von der Entwicklungsumgebung 

erzeugt wird. Auf der anderen Seite gab es mit dem Verlust der „Edit and Continue“-Funktion einen großen 

entwicklungstechnischen Rückschritt. So konnte man noch in der Version 6 im Debug-Modus den Code ändern und 

die Ausführung ohne Unterbrechung weiterlaufen lassen, was in VB.NET 2002 nicht mehr möglich war, in der 

übernächsten Version (Visual Basic 2005) jedoch wieder eingeführt wurde. 

Mit Visual Basic .NET kann man auch Web-Anwendungen erstellen, indem man den VB-Code in einer 

ASP.NET-Umgebung laufen lässt. Die hier verwendete GUI-Bibliothek heißt Web Forms und ist größtenteils eine 

Anpassung von Windows-Forms-Elementen an die Möglichkeiten von Webbrowsern und sonstigen Webclients. 

Die Umstellung von früheren Visual-Basic-Versionen, welche in Abgrenzung zu Visual Basic .NET Visual Basic 

Classic genannt werden, bringt einige Probleme mit sich: Da die Sprache und die Funktionsbibliothek so 

tiefgreifende Änderungen erfahren haben, kann ein Visual-Basic-Classic-Codeprojekt nur mit großem Aufwand auf 

die neue Version migriert werden. Microsoft liefert zwar mit seiner Entwicklungsumgebung Visual Studio einen 

sogenannten Migrationsassistenten mit. Dieser wandelt die Codestruktur meist korrekt um und beherrscht bis auf 

wenige Spezialfälle die Konvertierung von Thunder Forms nach Windows Forms, hat aber zum Beispiel starke 

Probleme mit Grafikprogrammierung, da die verwendeten Grafiksysteme von Visual Basic Classic (GDI, in 

Thunder-Forms-Steuerelementen gekapselt) und Visual Basic .NET (GDI+) praktisch inkompatibel zueinander sind. 

Zur besseren Portierung gibt es von Microsoft neben dem Migrationsassistenten eine Funktionssammlung im 

.NET-Framework (im Microsoft.VisualBasic-Namensraum), die einige wichtige Visual-Basic-Classic-Funktionen 

unter .NET zur Verfügung stellt. Bestehende COM-Komponenten können ohne Einschränkungen weiterbenutzt 


Seit Visual Basic .NET wird Visual Basic nur noch als Teil von Microsoft Visual Studio angeboten. Visual Basic 7 

wurde mit „Visual Studio .NET 2002“ ausgeliefert und basiert auf dem .NET-Framework, Version 1.0 (build 3705). 

Das erste Update auf Visual Basic 7.1 bzw. .NET-Framework 1.1 (build 4322) sowie „Visual Studio .NET 2003“ 

brachte nur kleinere Änderungen, was sich im „kleinen“ Versionssprung widerspiegelt. Etwa kann ab Visual Basic 

7.1 eine Zählervariable im Kopf einer For-Schleife deklariert werden. Außerdem wurde die Unterstützung für 

mobile Geräte hinzugefügt. Auf diesen dient nicht das .NET-Framework 1.1 als Laufzeitumgebung, sondern das


„.NET Compact Framework 1.0“. 

In Visual Basic .NET kann man, anders als in Visual Basic Classic, auch dann Programme erstellen, wenn man keine 

Entwicklungsumgebung erworben hat. Das .NET-Framework verfügt nämlich aus technischen Gründen über einen 

Kommandozeilencompiler namens vbc.exe. 

2005–2007: Visual Basic 8 und 9 

Im November 2005 erfolgte der erste große Versionssprung des .NET-Frameworks und des 

.NET-Compact-Frameworks auf Version 2.0, begleitet von der Veröffentlichung des neuen Visual Basic 8 als Teil 

von „Visual Studio 2005“ (das „.NET“ ist aus dem Namen entfallen). Mit dieser Version wurden einige 

Restrukturierungen an der .NET-Laufzeitbibliothek vorgenommen. Am auffälligsten ist die Unterstützung der 

generischen Programmierung, die den aus C++ bekannten Templates ähnelt. Viele Schnittstellen und Attribute der 

Laufzeitbibliothek sind auch als generische Implementation verfügbar. Weiter ist seit der Version 2005 eine 

kostenlose, leistungsfähig eingeschränkte Express Edition von Visual Basic .NET verfügbar. [3] 

Mit Visual Basic 8 wurde der Operator IsNot eingeführt, der Aufsehen erlangte, als Microsoft sich diese Erfindung 

patentieren ließ. [4] Eine andere Neuerung ist der My-Namensraum, der unterschiedliche systemabhängige Funktionen 

in einer für den Programmierer übersichtlichen Weise darstellt, etwa den Zugriff auf Computerkomponenten, die 

Windows-Registrierungsdatenbank oder Informationen über das Betriebssystem und den aktuellen Benutzer. 

2007 wurde parallel zur Veröffentlichung von Windows Vista die neue Visual-Basic-Version 9 [5] bzw. das „Visual 

Studio 2008“ veröffentlicht. Die größte sprachliche Änderung ist wohl die Unterstützung der neuen 

.NET-Komponente LINQ. Visual Basic 9 basiert auf dem mit Windows Vista ausgelieferten und für Windows XP 

erhältlichen .NET-Framework 3.0 (vormals WinFX). Der wohl bedeutendste Bestandteil des Versionsupdates ist die 

Windows Presentation Foundation, die nicht nur Windows Forms, sondern auch das Windows-interne 

Grafiksubsystem GDI ablöst. [6] 

Seit November 2007 basieren alle Visual-Studio-2008-Versionen auf dem .NET-Framework 3.5, mit dem die 

folgenden Technologien eingeführt bzw. erweitert wurden: Language Integrated Query (LINQ), neue Compiler für 

C#, Visual Basic und C++, ASP.NET mit AJAX, ADO.NET Entity Framework, Datenanbieterunterstützung für SQL 

Server 2008, Unterstützung für .NET Framework Client Profile u.a.. [7] 

Ableger 

Aufgrund seiner Popularität und einfachen Erlernbarkeit wurde Visual Basic Classic von Microsoft für verschiedene 

spezifische Umgebungen adaptiert. 

Visual Basic Script 

→ Hauptartikel: Visual Basic Script 

Visual Basic Script (kurz: VBScript oder VBS) ist eine interpretierte Visual-Basic-Variante, die zum Erstellen von 

dynamischen Webseiten oder kleineren Scripts eingesetzt wird. Die Sprache verwendet die gleiche Syntax wie 

Visual Basic Classic. Oberflächen können nicht direkt, sondern nur indirekt durch Einbetten des VBScript-Codes in 

HTML über den Windows Scripting Host erstellt werden. Dabei kann VBS auf alle COM-Objekte mit 

IDispatch-Schnittstelle zugreifen. VBS wurde außer für Windows- und clientseitige Web-Scripts auch für 

serverseitige Web-Scripts in einer ASP-Umgebung verwendet. Mit ASP.NET wurde VBS jedoch durch VB.NET 

verdrängt.


Visual Basic for Applications 

→ Hauptartikel: Visual Basic for Applications 

Visual Basic for Applications (kurz: VBA) ist ebenfalls eine auf Visual Basic Classic basierende interpretierte 

Skriptsprache. Sie wurde speziell zum Automatisieren wiederkehrender Aufgaben innerhalb anderer Programme 

entwickelt und hat große Popularität erlangt, seit Microsoft es mit seinem Büroprogramm Office ausliefert. Über die 

ältesten VBA-Anbindungen verfügen Microsoft Excel, Microsoft Access (beide seit 1995) und Microsoft Word (seit 

1997). Auch VBA konkurriert mit .NET, da Visual Studio .NET mit den Visual Studio Tools for Applications 

(vormals Visual Studio Tools for Office) ausgeliefert wird, die eine ähnliche Funktion wie VBA übernehmen. 


Die (historisch bedingt) populärste integrierte Entwicklungsumgebung für Visual Basic ist „Microsoft Visual Basic“ 

bzw. „Microsoft Visual Studio“, zu der es lange Zeit keine Alternative gab. Für Visual Basic .NET gibt es jedoch 

eine freie Entwicklungsumgebung namens SharpDevelop (kurz: #develop). Es gibt außerdem eine Express Edition 

von Visual Basic, die kostenfrei und gerade für Anfänger geeignet ist. 

Syntaxbeispiele 

Um einen Vergleich zu ermöglichen, erfüllen alle der folgenden Programme denselben Zweck: Sie geben alle ein 

Hinweisfeld mit dem Inhalt „Hallo Welt!“ aus. 

Syntax von Visual Basic Classic 

Die Syntax von Visual Basic Classic ist sehr stark an QuickBasic angelehnt. Dieses Beispiel enthält die Startfunktion 

Main des Programmes. Der Befehl MsgBox erstellt das Meldungsfeld. 

Sub Main() 

End Sub 

MsgBox "Hallo Welt!" 

Das untere Beispiel zeigt eine Formular-Ereignisbehandlungsroutine für die Schaltfläche Command1. 

Private Sub Command1_Click() ' Wenn man auf den Button klickt 

erscheint in einem Bezeichnungsfeld 

End Sub 

Label1.Caption = "Hallo Welt!" ' die Nachricht Hallo Welt 

Syntax von Visual Basic .NET 

Visual Basic .NET verfügt über Befehle, die denen von Visual Basic Classic sehr ähnlich sind. Diese 

VB.NET-spezifischen Zusatzfunktionen erleichtert vor allem die Konvertierung von Visual-Basic-Classic-Code 

nach Visual Basic .NET. So ist das folgende Visual-Basic-.NET-Codebeispiel dem vorangehenden sehr ähnlich. Die 

MsgBox-Funktion befindet sich hier im Microsoft.VisualBasic-Namensraum, der eine Kompatibilitätsschicht 

zwischen der .NET-Laufzeitbibliothek und der alten Visual-Basic-Funktionsbibliothek darstellt. 

Module Hello 

Public Sub Main() 

End Sub 

End Module 

MsgBox("Hallo Welt!")


Mit Visual-Basic-.NET-Mitteln lässt sich dieser Code statt als Modul auch als Klasse realisieren. Diese 

Vorgehensweise hat den Vorteil, dass sie sich leichter erweitern lässt und sich besser in das Konzept von .NET 

einfügt. In der Klasse ist die Main-Funktion ein statisches Mitglied, kann also ohne Instanz aufgerufen werden. 

(Siehe auch Objektorientierte Programmierung.) 

Public Class Form1 

Private Sub Form1_Load(ByVal sender As Object, ByVal e As 

System.EventArgs) Handles Me.Load 

End Sub 

End Class 

MessageBox.Show("Hello World!") 

In der Visual-Basic-.NET-Klasse sind manche Funktionen nur noch gebräuchlich, um Informationen zu gewinnen. 

Hier würde MsgBox nur benutzt, um den gedrückten Button zu ermitteln: 

Class Hello 

Public Shared Sub Main() 

Dim a 

a = MsgBox("Hallo Welt!", MsgBoxStyle.YesNo) ' a ist jetzt der 

Wert, den der gedrückte Button zurückgibt 

End Sub 

End Class 

Besonderheiten 

Als .NET-Sprache unterliegt Visual Basic .NET den Vor- und Nachteilen dieser Plattform. Visual Basic Classic 

machte viele kleinere Dinge anders als andere Sprachen. Aus Gründen der Abwärtskompatibilität sind viele dieser 

Punkte als „Altlasten“ in Visual Basic .NET enthalten. Einige Beispiele: 

• Üblicherweise (so auch im .NET Framework) entspricht der in eine Zahl konvertierte logische Wert Falsch bzw. 

False dem Wert 0, Wahr oder True wird als 1 interpretiert. In Visual Basic Classic steht True aber für -1. Diese 

Konvention erlaubte es, nicht zwischen einem logischen und einem binären Not-Operator unterscheiden zu 

müssen (-1 = 11111111 in Zweierkomplementdarstellung). Daher ergeben in Visual Basic .NET die 

Konvertierungen CInt(True) oder CType(True, Int32) immer noch den Wert -1; der Aufruf der .NET 

Framework-Methode Convert.ToInt32(True) evaluiert hingegen auf 1. 

• In den meisten Programmiersprachen deklariert eine Anweisung der Form int a[5]; ein fünfelementiges Array mit 

Indizes von 0 bis 4 oder von 1 bis 5. In VB.NET deklariert Dim a(5) As Integer ein sechselementiges Array mit 

Indizes von 0 bis 5, um abwärtskompatibel zur VB Classic Syntax Dim a([lowerBound To] upperBound) zu 

bleiben. 

• Visual Basic .NET erlaubt es, anders als zum Beispiel C#, globale Variablen ohne Klassenzugehörigkeit zu 

definieren. Dies widerspricht dem objektorientierten Paradigma (keine Deklaration ohne Klasse) und kann für 

unübersichtlichen und schwer wartbaren Code sorgen, wenn sich globale Deklarationen über viele Module im 

Projekt erstrecken.


Rechtliche Aspekte 

Visual Basic Classic ist, anders als viele moderne Hochsprachen, kein offener Standard, sondern proprietär und 

geistiges Eigentum von Microsoft. Dadurch ist Visual Basic Classic normalerweise auch an Microsoft Windows 

gebunden, also nicht portabel zu anderen Betriebssystemen. Mit Visual Basic .NET hat sich diese Bindung gelockert, 

da einige Teile der .NET-Infrastruktur durch die Ecma International offen standardisiert worden sind. Die 

Patentierung des in Visual Basic .NET 8 eingeführten IsNot-Operators hat diese Bedenken jedoch wieder verstärkt. 

Literatur 

• Klaus Werner Wirtz: Objektorientierte Programmentwicklung mit Visual Basic .NET Band 1 – Grundlagen [8] . 

Oldenbourg 2008, ISBN 978-3-486-58603-9. 

• Thomas Theis: Einstieg in Visual Basic 2008 [9] . Galileo Computing, 2008, ISBN 978-3-8362-1192-5. 

• René Martin: Einstieg in VB.NET [10] . Galileo Computing, 2003, ISBN 3-89842-277-1. 

• Joachim Fuchs, Andreas Barchfeld: Das Visual Basic 2005 Codebook. Addison Wesley in Pearson Education 

Deutschland, München 2006, ISBN 3-8273-2272-3. 

• Peter Monadjemi: Visual Basic 2005 Kompendium, 2006 Markt-und-Technik. 

• Klaus Löffelmann: Visual Basic 2008 – Das Entwicklerbuch, 1428 Seiten, 2008 Microsoft Press, ISBN 

978-3-86645-506-1. 

Weblinks 

• MSDN Developer Center – Visual Basic [11] 

• Get the BASICs. VB.NET für Einsteiger und Umsteiger in zehn Teilen [12] – MSDN Webcast 

• Bills Neunte [13] – Artikel zu den Neuerungen bei Visual Basic 9 

• Links zum Thema Visual Basic [14] im Open Directory Project 

• Visual Basic 2005 – Das Entwicklerbuch (Klaus Löffelmann) als PDF-Dokument [15] 

• Visual Basic 2008 – Der Crashkurs (Klaus Löffelmann) als PDF-Dokument [16] 

• Webcasts (Lernvideos): von Visual Basic 6 zu Visual Basic 2008 [17] 

• .NET-Technologien in Visual Basic 6.0 [18] 

• Visual Basic 2008 Express [19] 

• OpenBook von Galileo-Computing [20] 

Referenzen 

[1] http:/ / msdn. microsoft. com/ de-de/ vbasic/ 

[2] Von QBasic nach VBDOS / VBWIN (http:/ / www. antonis. de/ qb2vb/ index. htm) 

[3] Produktseite Visual Basic Express Edition (http:/ / www. microsoft. com/ germany/ express/ product/ visualbasicexpress. aspx) 

[4] Patent auf den IsNot-Operator (http:/ / appft1. uspto. gov/ netacgi/ nph-Parser?Sect1=PTO1& Sect2=HITOFF& d=PG01& p=1& u=/ 

netahtml/ PTO/ srchnum. html& r=1& f=G& l=50& s1="20040230959". PGNR. & OS=DN/ 20040230959& RS=DN/ 20040230959) 

(englisch) 

[5] Überblick über die Änderungen in Visual Basic 9 (http:/ / msdn. microsoft. com/ de-de/ library/ ms364068. aspx) (englisch) 

[6] Zukünftige Visual-Studio-Versionen (http:/ / msdn. microsoft. com/ de-de/ vstudio/ bb936699. aspx) (englisch) 

[7] Architektur von .NET Framework 3.5 (http:/ / msdn. microsoft. com/ de-de/ library/ bb822049. aspx) (deutsch) 

[8] http:/ / www08. mg. hs-niederrhein. de/ wi/ dozenten/ wirtz/ publikationen/ visualbasicnetgrundlagen. html 

[9] http:/ / www. galileocomputing. de/ openbook/ einstieg_vb_2008/ 

[10] http:/ / www. galileocomputing. de/ openbook/ vb_net/ 

[11] http:/ / msdn. microsoft. com/ de-de/ vbasic/ default. aspx 

[12] http:/ / www. microsoft. com/ germany/ msdn/ webcasts/ serien/ MSDNWCS-0610-01. mspx 

[13] http:/ / it-republik. de/ dotnet/ artikel/ Bills-Neunte-1503. html 

[14] http:/ / www. dmoz. org/ World/ Deutsch/ Computer/ Programmieren/ Sprachen/ Visual_Basic/ 

[15] http:/ / www. microsoft. com/ germany/ msdn/ aktuell/ news/ MicrosoftVisualBasic2005DasEntwicklerbuch. mspx 

[16] http:/ / www. microsoft-press. de/ product. asp?cnt=product& id=ms-5518


[17] http:/ / www. microsoft. com/ germany/ msdn/ webcasts/ serien/ MSDNWCS-0808-01. mspx 

[18] http:/ / msdn. microsoft. com/ de-de/ vbrun/ 

[19] http:/ / www. microsoft. com/ germany/ Express/ download/ downloaddetails. aspx?p=vb 

[20] http:/ / openbook. galileocomputing. de/ einstieg_vb_2008/

Esotherische Programmiersprachen 

Esoterische Programmiersprache 

Esoterische Programmiersprachen sind Programmiersprachen, die nicht für den praktischen Einsatz entwickelt 

wurden, sondern ungewöhnliche Sprachkonzepte umsetzen. Eine einfache Bedienung ist selten, teilweise werden 

Sprachen konzipiert, um möglichst komplizierte Algorithmen oder unverständliche Syntax zu haben, oft aber auch 

um neue Ideen auszuprobieren, oder um ungewöhnliche Möglichkeiten wie extreme Vereinfachung aufzuzeigen. Mit 

Esoterik im umgangssprachlichen Sinn haben „esoterische Programmiersprachen“ nichts zu tun. 

Die Motivation hinter der Entwicklung von esoterischen Programmiersprachen kann unterschiedlich sein. In einigen 

Fällen handelt es sich schlicht um akademische Scherze, häufig setzt sich aber der Entwickler der Sprache ein 

bestimmtes Ziel. So wurden zum Beispiel bei Brainfuck konventionelle Spracheigenschaften so weit wie möglich 

entfernt, bis eine turingmaschinenähnliche Sprache übrig blieb, die mit einem extrem kleinen Compiler auskommt. 

Die Beschäftigung mit esoterischen Programmiersprachen kann zu tieferem Verständnis seriöser 

Programmiersprachen sowie zur Verbesserung strukturellen Denkens führen. Praktische Bedeutung haben die 

esoterischen Programmiersprachen somit in Forschung und Lehre. Abhängig vom verfolgten Konzept können 

esoterische Programmiersprachen Konzepte für Sprachdesign und/oder Systemdesign demonstrieren. Allerdings gibt 

es eine Vielzahl von esoterischen Programmiersprachen, die nicht originär sind, sondern nur Konzepte anderer 

esoterischer Programmiersprachen unwesentlich verändern. 

Einer der produktivsten Entwickler esoterischer Programmiersprachen ist David Morgan-Mar [1] 

deutschsprachigen Raum Gerson Kurz [2] . 

Beispielsprachen 

• 3Code von Sean Heber 

• Beatnik (Wörter stehen für ihre Scrabble-Werte) von Cliff L. Biffle 

• Befunge (zweidimensionale Sprache) von Chris Pressey 

• Bo³ (ähnlich Befunge) von Markus Bode 

• BIT von David Morgan-Mar 

• Brainfuck (minimale imperative Programmiersprache, winziger Compiler) von Urban Müller 

• Brainfuck2D (Brainfuck auf die Ebene projiziert) 

• Chef (Code sieht aus wie ein Kochrezept) von David Morgan-Mar 

• Cow (Code besteht aus Kuhlauten (Moo), basiert auf Brainfuck) von Sean Heber 

• Emoticon (hat Emoticons als Befehle) 

• Haifu von David Morgan-Mar 

• HQ9+ (Programmiersprache spezialisiert auf triviale Aufgaben) von Cliff L. Biffle 

• INTERCAL (sollte das Programmieren erschweren) von Donald R. Woods und James M. Lyon 

• Iota and Jot (hat nur 2 Befehle) 

• Java2K (Wahrscheinlichkeitstheoretische Sprache) von Gerson Kurz 

• KaForkL (Programmieren mit RGB-Bildern inklusive grafischer IDE) von Kore Nordmann [3] 

• LOLCODE (Die Syntax besteht aus falsch geschriebenem Netzjargon.) von Adam Lindsay 

• Loopy (ähnlich Brainfuck2D) 

• Malbolge (erklärtermaßen schlimmste Programmiersprache) von Ben Olmstead 

• Ook! (Syntax besteht einzig und allein aus dem Wort „Ook“ sowie den Zeichen: .?!) von David Morgan-Mar 

, im 

180

Esoterische Programmiersprache 181 

• Piet (Programmcode besteht aus Bildern) von David Morgan-Mar 

• Shakespeare Programming Language (Code sieht wie ein Stück von Shakespeare aus) Kalle Hasselström und Jon 

Åslund 

• Taxi (Wegbeschreibung an einen Taxifahrer) von Sean Heber 

• Unlambda (Minimale funktionale Programmiersprache) 

• Whirl von Sean Heber 

• Whenever von David Morgan-Mar 

• Whitespace (Code besteht nur aus nichtdruckbaren Zeichen) von Edwin Brady und Chris Morris 

• ZOMBIE von David Morgan-Mar 

Literatur 

• Oliver Lau, Hexenwerk - Ein Plädoyer für esoterische Programmiersprachen, c’t 22/07, S. 192-199. 

Weblinks 

• The Esoteric Programming Languages Ring [4] 

• Vortrag: Vom Nutzen unnützer Programmierung [5] 

• Esolang wiki [6] Ein Wiki, das sich mit esoterischen Programmiersprachen beschäftigt (en) 

• The LOLCODE Wiki [7] 

Referenzen 

[1] DM's Esoteric Programming Languages (http:/ / www. dangermouse. net/ esoteric/ ) 

[2] programming languages (http:/ / p-nand-q. com/ humor/ programming_languages. html) 

[3] KaForkL - image programming language (http:/ / kore-nordmann. de/ projects/ kaforkl/ index. html) 

[4] http:/ / b. webring. com/ hub?ring=esolang 

[5] http:/ / ulm. ccc. de/ ~schabi/ weirdprog20c3/ 

[6] http:/ / esoteric. voxelperfect. net/ wiki/ Main_Page 

[7] http:/ / lolcode. com/

Brainfuck 182 

Brainfuck 

Brainfuck ist eine so genannte esoterische Programmiersprache, entworfen vom Schweizer Urban Müller um 1993. 

Die Sprache wird manchmal auch Brainf*ck, Brainf*** oder BF genannt. 

Brainfuck ist zwar für den ernsthaften Einsatz zu umständlich und ineffektiv, aber gut geeignet um Grundlagen der 

Computertechnik zu lernen. Speziell zeichnet sich Brainfuck durch ein extrem einfaches Sprachkonzept und 

hochkompakte Realisierung des Compilers aus, gleichzeitig wurde aber die (prinzipielle) universelle Einsetzbarkeit 

nicht eingeschränkt. 

Allgemeines 

Müllers Ziel war es, eine einfache Turing-vollständige Sprache zu entwerfen, welche mit einem möglichst kleinen 

Compiler übersetzt werden konnte – inspiriert wurde er dabei durch False, eine andere esoterische 

Programmiersprache, deren Compiler nur 1024 Byte groß war. Er schaffte es schließlich, die zweite Version seines 

Compilers für den Amiga in lediglich 240 Byte zu schreiben. Brian Raiter gelang es, dies zu unterbieten, indem er – 

unter Verwendung von nur 171 Bytes – einen Brainfuck-Compiler für x86 Linux schrieb. Für MS-DOS gibt es einen 

Brainfuck-Interpreter von Bertram Felgenhauer mit einer Größe von nur 98 Bytes. [1] 


Ein BF-Programm ähnelt stark der formalen Definition einer Turingmaschine. Statt eines Lese-/Schreibkopfes auf 

einem Band, Zuständen sowie einem frei definierbaren Alphabet werden jedoch im Sinne einer iterativen 

Programmiersprache ein Zeiger auf ein Datenfeld, Schleifenkonstrukte und eine rudimentäre ALU verwendet. Der 

Programmcode wird dabei separat vom Datenfeld gespeichert. (siehe Harvard-Architektur) 

Befehlssatz 

Brainfuck besitzt acht Befehle, jeweils bestehend aus einem einzigen Zeichen: 

Zeichen C-Äquivalent Semantik 

> ++ptr; inkrementiert den Zeiger 

< --ptr; dekrementiert den Zeiger 

+ ++*ptr; inkrementiert den aktuellen Zellenwert 

- --*ptr; dekrementiert den aktuellen Zellenwert 

. putchar(*ptr); Gibt den aktuellen Zellenwert als ASCII-Zeichen auf der Standardausgabe aus 

, *ptr = 

getchar(); 

Liest ein Zeichen von der Standardeingabe und speichert dessen ASCII-Wert in der aktuellen Zelle 

[ while (*ptr) { Springt nach vorne, hinter den passenden ]-Befehl, wenn der aktuelle Zellenwert null ist 

] } Springt zurück, hinter den passenden [-Befehl, wenn der aktuelle Zellenwert verschieden von null ist 

Anmerkung: Es gibt verschiedene semantisch äquivalente Varianten der letzten beiden Befehle, die hier angegebenen 

lassen sich jedoch am effizientesten implementieren. 

Andere im Quelltext vorkommende Zeichen (z. B. Buchstaben, Zahlen, Leerzeichen, Zeilenumbrüche) werden in der 

Regel ignoriert und können so als Quelltextkommentar verwendet werden.

Brainfuck 183 

Turing-Vollständigkeit 

Für verschiedene BF-Umgebungen wurde Turing-Vollständigkeit bewiesen: 

• Für ein unendlich großes Feld aus Zellen unendlicher Größe durch Frans Faase [2] 

• Für ein unendlich großes Feld aus Zellen endlicher Größe durch Daniel B. Cristofani [3] 

• Für ein endlich großes Feld aus Zellen unendlicher Größe durch Daniel B. Cristofani [4] 

Bei einer BF-Variante mit endlicher Zellgröße sowie endlicher Feldgröße (z. B. BFmin) handelt es sich − wie bei 

jedem realen Computer − um einen endlichen Automaten. 

Beispielprogramme in Brainfuck 

Hello World! 

Das folgende Programm gibt „Hello World!" und einen Zeilenumbruch aus. 

++++++++++ 

[ 

>+++++++>++++++++++>+++>+. // Zeilenumbruch 

Zur besseren Lesbarkeit ist dieser Brainfuckcode auf mehrere Zeilen verteilt und kommentiert worden. Brainfuck 

ignoriert alle Zeichen, die keine Brainfuckbefehle sind. Alle Zeichen mit Ausnahme von +-[],. können deswegen 

zur Kommentierung der Quellcodes genutzt werden. 

Zunächst wird die erste (die „nullte“) Zelle des Datenfelds auf den Wert 10 gesetzt (a[0] = 10). Die Schleife am 

Anfang des Programms errechnet dann mit Hilfe dieser Zelle weitere Werte für die zweite, dritte, vierte und fünfte 

Zelle. Für die zweite Zelle wird der Wert 70 errechnet, welcher nahe dem ASCII-Wert des Buchstaben 'H' 

(ASCII-Wert 72) liegt. Die dritte Zelle erhält den Wert 100, nahe dem Buchstaben 'e' (ASCII-Wert 101), die vierte 

den Wert 30 nahe dem Wert für Leerzeichen (ASCII-Wert 32), die fünfte den Wert 10, welches dem ASCII-Zeichen 

„Line Feed“ entspricht und als Zeilenumbruch interpretiert wird (oder werden sollte, siehe dazu den Abschnitt 

„Implementierungen“). 

Die Schleife errechnet die Werte, indem einfach auf die zu anfangs mit 0 initialisierten Zellen 10-mal 7, 10, 3 und 1 

addiert wird. Nach jedem Schleifendurchlauf wird a[0] dabei um eins verringert, bis es den Wert 0 hat und die 

Schleife dadurch beendet wird. 

Am Ende der Schleife hat das Datenfeld dann folgende Werte: a[0] = 0; a[1] = 70; a[2] = 100; a[3] 

= 30; a[4] = 10;

Brainfuck 184 

Als nächstes wird der Zeiger auf die zweite Zelle des Datenfelds (a[1]) positioniert und der Wert der Zelle um zwei 

erhöht. Damit hat es den Wert 72, welches dem ASCII-Wert des Zeichens 'H' entspricht. Dieses wird daraufhin 

ausgegeben. Nach demselben Schema werden die weiteren auszugebenden Buchstaben mit Hilfe der durch die 

Schleife initialisierten Werte, sowie der bereits verwendeten Werte, errechnet. 

Grundlagen der Programmierung in Brainfuck 

Anmerkung: Obwohl die Zeichen // wie die aus anderen Programmiersprachen bekannten Kommentare aussehen, 

sind es keine. Deshalb wird ein Pluszeichen z. B. in n+1 als ein Inkrementierbefehl ausgewertet, im unten 

angegebenen Beispiel steht aus diesem Grund n plus 1. 

Schleifen 

Schleifen beginnen mit [ und enden mit ]. Die Schleife wird solange ausgeführt, bis die aktuelle Zelle 0 ist. Die 

einfachste sinnvolle Form ist die Nullschleife, die die aktuelle Zelle dekrementiert, bis diese Null ist: 

[-] 

Einfache Schleife 

,[.,] 

Einfaches Echo-Programm. Zeichen werden von der Standardeingabe gelesen und wieder auf die Standardausgabe 

ausgegeben. 

Bedingungen 

• x ungleich y (wird durch Subtraktion der beiden Zahlen erreicht) 

Wichtig ist, dass Zelle 0 auf 0 gesetzt ist, ansonsten kann es dazu kommen, dass der Bedingungsblock mehrmals 

aufgerufen wird. 

>+++++>++++ // addiere 5 zu Zelle 1 und 4 zu Zelle 2 

[-] // subtrahiere Zelle 2 von Zelle 1 

< // gehe zu Zelle 1 

[ // wird aufgerufen wenn Zelle 1 ungleich 0 ist 

< // gehe zu Zelle 0 (somit wird die Schleife 

nur ein mal durchlaufen) 

] 

Rechenoperationen 

Verschieben des Wertes einer Zelle in die nächste (zuerst Nullsetzung der Folgezelle, dann in einer Schleife 

Inkrementierung der Folgezelle, gleichzeitige Dekrementierung der aktuellen): 

>[-]+[-]>[-]+>+[-] // verschiebe Inhalt von Zelle n

Brainfuck 185 

plus 2 nach Zelle n 

+-+++++[>+>+[-][-]>[-]>[-][[-]>+>>]

Brainfuck 186 

[->+[>+[>>>>>[->++[[-]>+>>] 

> 

[[-]

Brainfuck 187 

Referenzen 

[1] (http:/ / www. hugi. scene. org/ compo/ compoold. htm#compo6) 

[2] BF is Turing-complete (http:/ / www. iwriteiam. nl/ Ha_bf_Turing. html) 

[3] http:/ / www. hevanet. com/ cristofd/ brainfuck/ utm. b 

[4] http:/ / www. hevanet. com/ cristofd/ brainfuck/ urmutm. b 

[5] (http:/ / freakx. net/ bf2d/ ) 

[6] http:/ / www. muppetlabs. com/ ~breadbox/ bf/ 

[7] http:/ / esoteric. sange. fi/ brainfuck/ 

[8] http:/ / koti. mbnet. fi/ villes/ php/ bf. php 

[9] http:/ / 4mhz. de/ bfdev. html 

[10] http:/ / www. my-palm. de/ 

[11] http:/ / www. feldkord-programming. de/ Programme. htm#Brainfuck-Compiler 

Brainfuck2D 

Brainfuck ist eine so genannte esoterische Programmiersprache, entworfen vom Schweizer Urban Müller um 1993. 

Die Sprache wird manchmal auch Brainf*ck, Brainf*** oder BF genannt. 

Brainfuck ist zwar für den ernsthaften Einsatz zu umständlich und ineffektiv, aber gut geeignet um Grundlagen der 

Computertechnik zu lernen. Speziell zeichnet sich Brainfuck durch ein extrem einfaches Sprachkonzept und 

hochkompakte Realisierung des Compilers aus, gleichzeitig wurde aber die (prinzipielle) universelle Einsetzbarkeit 

nicht eingeschränkt. 

Allgemeines 

Müllers Ziel war es, eine einfache Turing-vollständige Sprache zu entwerfen, welche mit einem möglichst kleinen 

Compiler übersetzt werden konnte – inspiriert wurde er dabei durch False, eine andere esoterische 

Programmiersprache, deren Compiler nur 1024 Byte groß war. Er schaffte es schließlich, die zweite Version seines 

Compilers für den Amiga in lediglich 240 Byte zu schreiben. Brian Raiter gelang es, dies zu unterbieten, indem er – 

unter Verwendung von nur 171 Bytes – einen Brainfuck-Compiler für x86 Linux schrieb. Für MS-DOS gibt es einen 

Brainfuck-Interpreter von Bertram Felgenhauer mit einer Größe von nur 98 Bytes. [1] 


Ein BF-Programm ähnelt stark der formalen Definition einer Turingmaschine. Statt eines Lese-/Schreibkopfes auf 

einem Band, Zuständen sowie einem frei definierbaren Alphabet werden jedoch im Sinne einer iterativen 

Programmiersprache ein Zeiger auf ein Datenfeld, Schleifenkonstrukte und eine rudimentäre ALU verwendet. Der 

Programmcode wird dabei separat vom Datenfeld gespeichert. (siehe Harvard-Architektur) 

Befehlssatz 

Brainfuck besitzt acht Befehle, jeweils bestehend aus einem einzigen Zeichen:


Zeichen C-Äquivalent Semantik 

> ++ptr; inkrementiert den Zeiger 

< --ptr; dekrementiert den Zeiger 

+ ++*ptr; inkrementiert den aktuellen Zellenwert 

- --*ptr; dekrementiert den aktuellen Zellenwert 

. putchar(*ptr); Gibt den aktuellen Zellenwert als ASCII-Zeichen auf der Standardausgabe aus 

, *ptr = 

getchar(); 

Liest ein Zeichen von der Standardeingabe und speichert dessen ASCII-Wert in der aktuellen Zelle 

[ while (*ptr) { Springt nach vorne, hinter den passenden ]-Befehl, wenn der aktuelle Zellenwert null ist 

] } Springt zurück, hinter den passenden [-Befehl, wenn der aktuelle Zellenwert verschieden von null ist 

Anmerkung: Es gibt verschiedene semantisch äquivalente Varianten der letzten beiden Befehle, die hier angegebenen 

lassen sich jedoch am effizientesten implementieren. 

Andere im Quelltext vorkommende Zeichen (z. B. Buchstaben, Zahlen, Leerzeichen, Zeilenumbrüche) werden in der 

Regel ignoriert und können so als Quelltextkommentar verwendet werden. 

Turing-Vollständigkeit 

Für verschiedene BF-Umgebungen wurde Turing-Vollständigkeit bewiesen: 

• Für ein unendlich großes Feld aus Zellen unendlicher Größe durch Frans Faase [2] 

• Für ein unendlich großes Feld aus Zellen endlicher Größe durch Daniel B. Cristofani [3] 

• Für ein endlich großes Feld aus Zellen unendlicher Größe durch Daniel B. Cristofani [4] 

Bei einer BF-Variante mit endlicher Zellgröße sowie endlicher Feldgröße (z. B. BFmin) handelt es sich − wie bei 

jedem realen Computer − um einen endlichen Automaten. 

Beispielprogramme in Brainfuck 

Hello World! 

Das folgende Programm gibt „Hello World!" und einen Zeilenumbruch aus. 

++++++++++ 

[ 

>+++++++>++++++++++>+++>+


>. // Zeilenumbruch 

Zur besseren Lesbarkeit ist dieser Brainfuckcode auf mehrere Zeilen verteilt und kommentiert worden. Brainfuck 

ignoriert alle Zeichen, die keine Brainfuckbefehle sind. Alle Zeichen mit Ausnahme von +-[],. können deswegen 

zur Kommentierung der Quellcodes genutzt werden. 

Zunächst wird die erste (die „nullte“) Zelle des Datenfelds auf den Wert 10 gesetzt (a[0] = 10). Die Schleife am 

Anfang des Programms errechnet dann mit Hilfe dieser Zelle weitere Werte für die zweite, dritte, vierte und fünfte 

Zelle. Für die zweite Zelle wird der Wert 70 errechnet, welcher nahe dem ASCII-Wert des Buchstaben 'H' 

(ASCII-Wert 72) liegt. Die dritte Zelle erhält den Wert 100, nahe dem Buchstaben 'e' (ASCII-Wert 101), die vierte 

den Wert 30 nahe dem Wert für Leerzeichen (ASCII-Wert 32), die fünfte den Wert 10, welches dem ASCII-Zeichen 

„Line Feed“ entspricht und als Zeilenumbruch interpretiert wird (oder werden sollte, siehe dazu den Abschnitt 

„Implementierungen“). 

Die Schleife errechnet die Werte, indem einfach auf die zu anfangs mit 0 initialisierten Zellen 10-mal 7, 10, 3 und 1 

addiert wird. Nach jedem Schleifendurchlauf wird a[0] dabei um eins verringert, bis es den Wert 0 hat und die 

Schleife dadurch beendet wird. 

Am Ende der Schleife hat das Datenfeld dann folgende Werte: a[0] = 0; a[1] = 70; a[2] = 100; a[3] 

= 30; a[4] = 10; 

Als nächstes wird der Zeiger auf die zweite Zelle des Datenfelds (a[1]) positioniert und der Wert der Zelle um zwei 

erhöht. Damit hat es den Wert 72, welches dem ASCII-Wert des Zeichens 'H' entspricht. Dieses wird daraufhin 

ausgegeben. Nach demselben Schema werden die weiteren auszugebenden Buchstaben mit Hilfe der durch die 

Schleife initialisierten Werte, sowie der bereits verwendeten Werte, errechnet. 

Grundlagen der Programmierung in Brainfuck 

Anmerkung: Obwohl die Zeichen // wie die aus anderen Programmiersprachen bekannten Kommentare aussehen, 

sind es keine. Deshalb wird ein Pluszeichen z. B. in n+1 als ein Inkrementierbefehl ausgewertet, im unten 

angegebenen Beispiel steht aus diesem Grund n plus 1. 

Schleifen 

Schleifen beginnen mit [ und enden mit ]. Die Schleife wird solange ausgeführt, bis die aktuelle Zelle 0 ist. Die 

einfachste sinnvolle Form ist die Nullschleife, die die aktuelle Zelle dekrementiert, bis diese Null ist: 

[-] 

Einfache Schleife 

,[.,] 

Einfaches Echo-Programm. Zeichen werden von der Standardeingabe gelesen und wieder auf die Standardausgabe 

ausgegeben.


Bedingungen 

• x ungleich y (wird durch Subtraktion der beiden Zahlen erreicht) 

Wichtig ist, dass Zelle 0 auf 0 gesetzt ist, ansonsten kann es dazu kommen, dass der Bedingungsblock mehrmals 

aufgerufen wird. 

>+++++>++++ // addiere 5 zu Zelle 1 und 4 zu Zelle 2 

[-] // subtrahiere Zelle 2 von Zelle 1 

< // gehe zu Zelle 1 

[ // wird aufgerufen wenn Zelle 1 ungleich 0 ist 

< // gehe zu Zelle 0 (somit wird die Schleife 

nur ein mal durchlaufen) 

] 

Rechenoperationen 

Verschieben des Wertes einer Zelle in die nächste (zuerst Nullsetzung der Folgezelle, dann in einer Schleife 

Inkrementierung der Folgezelle, gleichzeitige Dekrementierung der aktuellen): 

>[-]+[-]>[-]+>+[-] // verschiebe Inhalt von Zelle n 

plus 2 nach Zelle n 

+-+++++[>+>+[-]


Division funktioniert am einfachsten als restlose Division, alles andere resultiert in dem Fall in einer Endlosschleife. 

Die Idee ist ansonsten dieselbe wie bei der Multiplikation: p[1] = p[0] / 5; Nebeneffekt: p[0] = 0 

[>+>[-]>[-]>[-]>[-][[-]>+>>]] 

> 

[[-]


das heißt bei Verzweigungen teilt er sich, und ermöglicht damit (Pseudo-)Threads. 


Da Brainfuck keine standardisierte Programmiersprache ist, kann es zu Inkompatibilitäten kommen. Diese betreffen 

am häufigsten die verschiedenen Zeilenumbruchformate der Betriebssysteme Windows und Unix, sowie deren 

unterschiedliche Zeichencodes für die Eingabetaste. Die meisten Brainfuckprogramme, darunter auch die von Urban 

Müller, sind auf Unix-Umgebungen ausgelegt und können daher mit Implementierungen, die von 

Windows-Zeichencodes ausgehen, nicht korrekt übersetzt werden. 

Literatur 

• Oliver Lau, Hexenwerk - Ein Plädoyer für esoterische Programmiersprachen, c’t 22/07, S. 192-199. 

Weblinks 

• Brainfuck - An Eight-Instruction Turing-Complete Programming Language [6] von Brian Raiter 

• Brainfuck Archive [7] bei Panu Kalliokoski 

• Brainfuck Interpreter [8] , Brainfuck Code im Browser testen. 

• Brainfuck Developer [9] , eine Brainfuck-IDE für Windows 

• Brainfuck Palm-OS Engine und IDE [10] von Rudolf Seitz 

• Brainfuck Compiler [11] In Java programmierter Compiler. Erzeugt Java-Bytecode und erstellt eine ausführbare 

.jar-Datei aus diesem Programm. Von Sven Feldkord. 

Referenzen 

[1] (http:/ / www. hugi. scene. org/ compo/ compoold. htm#compo6) 

[2] BF is Turing-complete (http:/ / www. iwriteiam. nl/ Ha_bf_Turing. html) 

[3] http:/ / www. hevanet. com/ cristofd/ brainfuck/ utm. b 

[4] http:/ / www. hevanet. com/ cristofd/ brainfuck/ urmutm. b 

[5] (http:/ / freakx. net/ bf2d/ )


Quelle(n) und Bearbeiter des/der Artikel(s) 

ActionScript Quelle: http://de.wikipedia.org/w/index.php?oldid=71478717 Bearbeiter: Archiv, Bernd vdB, Blaufisch, Christian Scholz, ChristianErtl, Cljk, Comkee, Complex, Crux, Dinah, 

Doc-Holliday26, Edoe, EricPoehlsen, Filzstift, FutureCrash, Head, Hidd, Holly Tyler, HyperDagobert, INM, ITMönch, Ifrost, Ims, Jochen Hilgers, Joni2, Justy, Kai Baumgarten, Kku, Kubieziel, 

Kubrick, Laurusnobilis, Le petit prince, Madokan, Meph666, Merlissimo, MichaelDiederich, Mikepowers, Molily, Morki, Nolispanmo, Owltom, Peterlustig, Philipendula, Pjacobi, Prauch, 

Psyk42, Ralf5000, Revolus, STBR, Schnargel, Seewolf, Shepard, Srbauer, SteBo, Succu, Timothy da Thy, Tobias Bergemann, Tönjes, U86774, V.R.S., W!B:, WikiPimpi, Wikieditoroftoday, 87 

anonyme Bearbeitungen 

Algol 60 Quelle: http://de.wikipedia.org/w/index.php?oldid=70167254 Bearbeiter: Aka, Andre Engels, B. N., Bierdimpfl, ChristophDemmer, Daniel Mex, FutureCrash, Haring, HenrikHolke, 

Hubi, Humbug, Jpp, Karl-Henner, Kku, Ktnagel, Langec, Leider, Lenny222, MKI, Marc van Woerkom, Moros, Nd, PeterFrankfurt, Phe, Pit, Pruefer, Ptrs, Rotkaeppchen68, Schnargel, 

SebastianBreier, SonniWP, SonniWP2, Terabyte, Tsor, Uwe Hermann, Vrumfondel, Warp, Wegner8, Zeichenderzeit, Zeno Gantner, Zron, 24 anonyme Bearbeitungen 

AppleScript Quelle: http://de.wikipedia.org/w/index.php?oldid=72228233 Bearbeiter: Bdk, Bgeissl, D, DE, Don Leut, Filzstift, Fomafix, Hagbard, Jamie starr, JasN, Jwdietrich2, Karl-Henner, 

Kubieziel, Lichtkind, Lukas Niemeyer, Menphrad, Polluks, Romancieslik, Sarkana, Sparti, Wecu, Wiegels, 33 anonyme Bearbeitungen 

Assemblersprache Quelle: http://de.wikipedia.org/w/index.php?oldid=72354265 Bearbeiter: 45054, Abigor, Ahoerstemeier, Aleks-ger, Amens, ArchiSchmedes, Avoided, BKS-Ordner, 

BLueFiSH.as, Baumanns, Baxerus, Bdk, Ben-Zin, Bernard Ladenthin, Bholliger, Carbenium, Chiananda, ChristianHujer, Ckeen, Complex, Conny, Conversion script, Cortex a8, Cryjack, D, 

DarkDust, Diba, Doodee, Drccpp, Ephraim33, Estron, Euku, Fgb, Frank Murmann, Gum'Mib'Aer, Harald Tribune, Hirzel, Homer Landskirty, Hubi, Humbug, Ichmichi, Jan Giesen, Jens Prüfer, 

Joho345, Julben, Karl-Henner, Kickof, Kurt Jansson, Leider, Littl, LivingShadow, Logopodo, LosHawlos, MFM, Magnus, MalteAhrens, Marco Breuer, Mario Blunk, Markus Moll, Martin-vogel, 

Masterbrain, Matthias Winkelmann, Matthäus Wander, Melmei, Mh, Mikue, Moon2005, Nschle85, OliverWeidel, Oreissig, Paethon, Pausetaste, Peter(TOO), Peter200, PeterVitt, Piefke, 

Pomponius, Protossdesign, Pruefer, Ramgeis, Reptilologe, Ringler, Rtc, Schewek, Schlesinger, Sicaine, Siegmaralber, Sim.krueger, Sinn, StYxXx, Stargaming, Stefan Kühn, Stefan506, Stern, 

Stevemitchell, T0ast3r, Terabyte, Thüringer, Tiago, Tinz, Traroth, Trockenfisch, Tux edo, VampLanginus, Video2005, WKr, WiESi, Wikipediaphil, Woches, XJamRastafire, YPkx22m40, 

YourEyesOnly, dialin-145-254-190-065.arcor-ip.net, א, 143 anonyme Bearbeitungen 

B (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=71936928 Bearbeiter: B0b, Conversion script, DaB., Das Ed, ER1984, Fomafix, Gms, Head, Kh555, Kingruedi, 

Klemen Kocjancic, Kurt Jansson, Ocrho, RokerHRO, Schewek, Sicherlich, Spinne, Steffen, Tobias Bergemann, Urizen, Znortquap, Zumbo, 6 anonyme Bearbeitungen 

BASIC Quelle: http://de.wikipedia.org/w/index.php?oldid=72412438 Bearbeiter: AFBorchert, Abubiju, Achim Raschka, Ae-a, Aka, Andre Engels, Andy king50, Arbol01, Archiv, Ardo Beltz, 

BLueFiSH.as, Ben-Zin, Benedikt, Bierdimpfl, Buddhanatur, Byteemoz, Cactus26, Complex, Conversion script, Cuno.1, CyranoJones, Dachris, DangerGround, Demicx, Djj, Djordjes, DocSnyder, 

EUBürger, Elvis untot, Entlinkt, ErnstRohlicek, Euphoriceyes, FelixBlumstrauß, Fomafix, Frank Murmann, Gansweith, Generator, HannesH, Hans Bauer, HaukeZuehl, Herr Th., Hubi, Jacco, 

Joho345, Jpp, Juesch, KaHe, Karl Gruber, Karl-Henner, Kassander der Minoer, Knoerz, Knorxx, Knuth Konrad, Kopoltra, Koyaanis Qatsi, LKD, Langec, Libro, Lichtkind, LustigerKreis, 

Löschfix, Magnus, Malcdu3, Mandi47, Manuel Krüger-Krusche, MarkusHagenlocher, MarkusKnittig, Martin Wantke, Martin-vogel, Matthäus Wander, Mh, Mijozi, Mikenolte, Mr. Anderson, 

Mr. B.B.C., Naddy, Nameless, Numbo3, Onegin, Paddy, PatriceNeff, Paul Ebermann, Peter200, PhilippWeissenbacher, Picpatz, Pittigrilli, Plenz, Polluks, Poxy, Raymond, Reinhard Kraasch, 

Rho, Robert Wünsche, RokerHRO, Schewek, Schildie, Sebs, Sesalo, Siego, Snevern, SonniWP2, Sovok, SpaceRat, Stefan h, Stefan2, SuperFLoh, T-st, TheK, Thornard, Till.niermann, 

TobiasHerp, Traroth, Tzzzpfff, Uimp, Ulsimitsuki, VampLanginus, Video2005, WAH, Wainberg.de, Wiegels, Wikipediaphil, Wikitroll, Wilske, Wurzeldrei, Zeno Gantner, Zinnmann, 

cache.it.helsinki.fi, pD902E342.dip.t-dialin.net, 186 anonyme Bearbeitungen 

Borland Delphi Quelle: http://de.wikipedia.org/w/index.php?oldid=65905886 Bearbeiter: - 

C (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=72294294 Bearbeiter: Achim Raschka, Achim.oetringhaus, Aconcagua, Ahoerstemeier, Ak1, Alexzop, 

Alicante1986, Andreas Stockter, AndreasB, Antonsusi, Archiv, Ath, Axelfarr, AydinC, B.Nafz, B0b, BLueFiSH.as, Bananeweizen, Barbulo, Baumanns, Bautsch, Ben-Zin, Benji, Bernard 

Ladenthin, BesondereUmstaende, Bitsandbytes, Bombenleger, Boris23, Brf, Cactus26, Carminox, Catmangu, Chewie100, Christoph D, Cient, Claudio Carobolante, Cliffhanger, Complex, Conny, 

Conversion script, Corbil, Cvk, DL5MDA, DaB., Dagobert Drache, Daniel B, DarkDust, DavidbowiE, Der Wolf im Wald, Derbrain, DeusTron, Develord, Dietmar Giljohann, Digedag1234, 

DocSnyder, Dr.Inform, Drahkrub, Duesentrieb, Dundak, Edding, Eozae, Epsilon, Estron, Euphoriceyes, FaUl, Fantomas, Fcc go, Flashenposter, Flo12, Flominator, Fomafix, Fristu, G, GDK, 

GNB, Gauss, Geekux, Georg-Johann, Gms, Gunther, HHK, Hannes Hirzel, Harald wehner, Hashar, He3nry, Head, Heizer, Himuralibima, Hokanomono, Howwi, Hubi, JAF, JensGoldbecker, 

Jivee Blau, Jodo, Jofi, Johnny drossel, Jojo-schmitz, Jonathan Hornung, Jpp, Jurpel, Jörg Weinmann, KL47, Kadeck, KagamiNoMiko, Karl-Henner, Kassander der Minoer, Kh555, Kingruedi, 

Knorxx, Koala, Koethnig, Kurt Jansson, Kurt seebauer, LKD, Landau, Lehrig, Lemzwerg, Levin, Liebeskind, Longamp, Lustiger seth, Lyserg, M43kS, MF-Warburg, MGla, Magnus, 

MarsMaster, Martin-vogel, Maveric149, Membeth, Merlin G., Mh, Miez, Mijobe, MikeTheGuru, Mikenolte, Montauk, Mr. Anderson, MrG de, Nachtgestalt, Nephelin, Neubert, NiTeChiLLeR, 

Nickiderweissehund, Nicolas G., Nikai, Noddy93, Norbert M. T., Noshow, Numbo3, Octotron, Onee, Otpyrc, Pascal76, PaterMcFly, PatriceNeff, Peter seibel, PhilippWeissenbacher, Planegger, 

Plasmagunman, Polluks, Preek, Programmierer, Prometeus, Q. Wertz, Quickfix, R2D2 C3PO, Ratopi, Reptilologe, Revvar, Richardigel, RokerHRO, RolandIllig, Roo1812, Rtc, SHerz, 

SK-Genius, SLXViper, STBR, Sansculotte, Sargoth, Schewek, Schily, Schnargel, Schnuffi72, Schoos, Schwans, Schweikhardt, Scooter, Scsboy1, Semper, Serpens, Sfischer, Shlomo, Sig11, 

Silberchen, Simonski, Skriptor, Snert, Sparti, StarShaper, Stefan Kögl, Stefan Kühn, Stefan Schultz, Steffen, Stern, Suedwand, Sysrq, TTL, Teewurst, TheK, ThiloSchulz, Tilo Körner, Tinz, 

Tirkon, Trac3R, Trustable, Tönjes, Ulrich.fuchs, Urs, WAH, Warp, Weede, WikiNick, Wikpeded, Wolle1024, Wuffel, YMS, Yanestra, Youandme, Zxb, 399 anonyme Bearbeitungen 

C+ + Quelle: http://de.wikipedia.org/w/index.php?oldid=72461588 Bearbeiter: AT, Abaumg, AbcAeffchen, Achim Raschka, Addicted, Aka, Akkarin, Alfred Nobel, Amin K, AndreasB, 

Androl, Apfelschorle, Aquisgranum, Arcy, Arpy, Aths, Augiasstallputzer, AydinC, BKSlink, BarkingFish, Ben-Zin, Bentakle, Bernard Ladenthin, BerndGehrmann, Berni, Bhabba, Bitsandbytes, 

BlackMaster, Bleichi, Brf, BuSchu, Bur, Callidior, Calvin-gr, Casoboy16, Ce, Ce2, Chatter, ChristianHujer, Christoph D, Ckeen, Codemaster, Complex, Conversion script, Corbil, Crux, Curtis 

Newton, Cvk, D, D0ktorz, Dachris, Data-Experts, Der Wolf im Wald, DeusTron, Dibe, Dinah, DocSnyder, Dodo von den Bergen, Dr.Inform, Dru56, Dtk, Dubbaluga, Dundak, E86, Edel682, 

Emes, Engie, Erhard Henkes, ErrorXVI, Euku, EvaK, Feder und Schwert, Ferk, Firefox13, Flagran, Flogger, Florian Keßeler, Flostre, Fomafix, Foobar, FutureCrash, Fuzzile, Ganomi, Gardini, 

Gauss, Giuly, Gnufix, Gnushi, Gorp, Gronau, Guandalug, Gunther, H4xX0r, HaTe, Hades, Hallo leute, He3nry, Head, Heinrich5991, Heinte, Helm, Hermann T., Herzl, High-Fish, HugoRune, 

Igge, Insider, Ixitixel, JAF, JD, Jackalope, Janmohr, Janni93, Johannes2, Jonathan Hornung, Jowereit, Jpp, Juesch, Jwnabd, Jón, KL47, Kadeck, Kaetsch, Kalumet, Karl Bednarik, Karottenreibe, 

Kassander der Minoer, Kate, Kh80, Kingruedi, Kleiner Revert, Knopper22, Koenraad, Kolk, Konrad F., Kopoltra, Kubrick, Kungfuman, Kurt Jansson, Kurt seebauer, Langec, LeClochard, 

Lennart Spitzner, Lenny222, Levin, Liebeskind, Longamp, Lostintranslation, MaKoLine, Magnus, Malteleip, Manu b, Marc van Woerkom, Marc-André Aßbrock, Markus Mueller, 

Markus.schulze, MarkusHagenlocher, Martin Fuchs, Martin-vogel, Matt314, Matthias Kupfer, Matthäus Wander, Memnon335bc, Merlin G., Merlissimo, Micwil, Mijobe, MikeTheGuru, 

Mikenolte, Mjoppien, Mnh, Mo4jolo, Morlang, Mps, Muck31, Mugros, Nd, Nephelin, Netzki, Newr.88.72, Nicolas G., Nk94.com, Nolispanmo, Norro, Nschle85, Nulobert, Numbo3, Ocrho, 

Old.cpp, Olei, Ominion, Otets, Paddy, Paethon, PaterMcFly, PatriceNeff, Paul Wenk, Pendulin, Perrak, Peter200, Philipendula, Pi, Pill, Pinetik, Pinguin.tk, Pit, Plucked, Pohli74, Poldi, Poxy, 

Provi-neu, R. Barth, Raimar, RalfG., René Schwarz, Revvar, Rho, Richardigel, Roadside Attractions, RobertoRSi, RokerHRO, Rolf D., Rudi Mentehr, S.K., Sallynase, Sammler05, San Jose, 

Sapn, Sargoth, Schilken, Schlesinger, SchwarzerKrauser, Sechmet, Seewolf, Sefi, SehLax, Semper, Sensenmann, Sfischer, ShadowCrawler, Simon2, Skriptor, Slt, Spartanischer Esel, Sparti, 

Speck-Made, StarShaper, Steef389, Stefan, Stefan Kühn, Stefan Schultz, Stern, Suit, Superbass, Synelec, Sypholux, T34, Taschenrechner, Terabyte, TheK, ThePacker, ThePeritus, Thomaswm, 

Thornard, Thüringer, Tobias Bergemann, Transor, Traroth, Traute Meyer, Trockenfisch, Trublu, Tsor, Tunichtgut, Tuxman, Ulz, Uwe Gille, Valnar, Vargenau, Vkoleviathan, VladimirTepes, 

Vlatterm, Volker Alexander, W.amadeus, Walter Koch, Warp, Wat kickstn so?, Wdwd, WebScientist, Webkid, Weede, Whitespace123, WiESi, Wie gesagt, Wikieditoroftoday, Wikihelp, 

Wilfried Elmenreich, Windharp, Wmbolle, Yetzt, YourEyesOnly, Zampano69, Zamperl5, Zeno Gantner, Zollernalb, Zook, Zuknapp, Zäh-Scharp, Überraschungsbilder, 691 anonyme 

Bearbeitungen 

C- Sharp Quelle: http://de.wikipedia.org/w/index.php?oldid=72436518 Bearbeiter: 21Cyberboy, APPER, Addicted, Adrianwn, Aka, Alexander Noé, Archiv, Arcy, Ardo Beltz, ArtMechanic, 

B0b, BSDev, Bitsandbytes, Blah, Blakeks, Blaubahn, Boogieman95028, CSonic, Carminox, ChristianErtl, Chrizel, Complex, D, Daniel Bovensiepen, DerAnalyst, Derwok, Djordjes, Doc z, 

Dundak, E7, Echom, Euku, Expent, Filzstift, Fjeller, Florian Adler, Fomafix, FordPrefect42, Frank Jacobsen, FrankDopatka, Generalpd, Guenson, HaukeIngmar, Helix91, HesseTom, High-Fish, 

Hurlbrink, Ijbond, J. 'mach' wust, J0eyB, JDF, Jackalope, Jan223, Janni79, Jpp, Just-Ben, Jutta234, Karl-Henner, KleinerHerbert, Knorxx, Koethnig, Konrad F., Kookaburra, Korinth, Krawi, Kvn, 

LKD, Leider, Lichtkind, Liquidat, Lofote, Lon Molescraft, LordDeath, M.L, Ma-Lik, Mannerheim, Marc H., MarcoBorn, Martin Herbst, Martin-vogel, Matthias M., Maynard, Mig000, 

Mikenolte, Moros, MovGP0, Mps, Mumme, Neitram, Nephelin, Netzki, Nils-Hero, Nolispanmo, Nonvolatil, Norro, Novox, Nrainer, Numbo3, Ohauahauaha, PIGSgrame, PSS, Paddy, 

PatriceNeff, Peating, Pemu, PerfektesChaos, Peter Steinberg, PeterReut, PeterVitt, Polarkreis0815, Prowal, RFranssen, Racer93, Reinhard Kraasch, Revvar, Ri st, Robb, Robert Wünsche, 

RohMusik, RokerHRO, Rotstifttäter, Rudimenter, STBR, Salmi, Scared, Schwarzweiß, Sebastian.Dietrich, Seufert, Sinn, Slady, Smach, Smurn, Snert, Spotty, Sprezzatura, StYxXx, Stamann, 

SteMicha, Stefan Schultz, StephanGrein, Stern, Stummvoll, ThoRr, Thomas Willerich, Thornard, Timekeeper, Torsch, Tribes, Ursb, UweHaupt, Vertigo21, Wiegels, WikiNick, Wikipediaphil, 

WoTsch, Wolle1024, XChris, Xanim, Zumbo, Zäh-Scharp, Україна, 298 anonyme Bearbeitungen 

COBOL Quelle: http://de.wikipedia.org/w/index.php?oldid=71561640 Bearbeiter: 7lima, Achim Raschka, Aka, Albu, Andre Engels, Andy king50, Ath, BKSlink, Baumfreund-FFM, 

Bender235, Bierdimpfl, Cactus26, Charmion, Clemfix, Dealerofsalvation, DerHexer, Dragan, Eike sauer, Emmo.Tevkliss, Felistoria, Fkuehne, Fomafix, Froggy, Gstueb, HV, Hcy, Head, 

Hieronymus A., Hpb, Hubi, Ikarus1969, Jailbird, Jed, John, John Eff, Jonelo, Joni2, Jpp, Kh80, Kubieziel, Kungfuman, L.Willms, Lateiner, Leider, Longamp, MacBarfuss, MarkusHagenlocher, 

Martin Herbst, Martin-vogel, Matthäus Wander, Moralapostel, Nameless, Nocturne, Ozuma, PhilippWeissenbacher, Pill, Python-Clown, Ralf Schroth, Ralf5000, RokerHRO, Roland Berger,


Sarang, Schatte, Siggi, Sslomski, Stefan Kühn, SuperFLoh, Sypholux, T1gerch3n, Tamas Szabo, Timothy da Thy, UlrichJ, Unscheinbar, Urfin, Usarobert, Velgreyer, Video2005, Warp, WeißNix, 

Wiki und ylvie, Wkrautter, Zangala, Zeno Gantner, Århus, 129 anonyme Bearbeitungen 

D (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=71824458 Bearbeiter: Avoided, B0b, Berliner Schildkröte, Bernard Ladenthin, Björn Bornhöft, Boemmels, 

Complex, D, Dapete, Dennis Westphal, DocSnyder, DrumsInVitro, Engie, Fast.ch, Flogger, Fomafix, Geist, der stets verneint, Gerold Broser, Hades, Haeber, Jpp, Juliana da Costa José, 

Keinfarbton, Knorxx, Kubieziel, Kuebi, Kuhlo, L9urch, Leider, Lichtkind, Mafutrct, Manni88, Manuae, Marcel Kaeming, Mark192, Martin Fuchs, Meph666, Mo4jolo, Muck31, No dammagE, 

Ocrho, Redder, Rohieb, RokerHRO, Salomonderossi, Simonski, Stern, TUFKAUP, TheHammer, Tuergeist, Tönjes, Umweltschützen, Uncopy, Vigilius, WeirdCat, WiESi, Xanim, 

YourEyesOnly, Zumbo, 103 anonyme Bearbeitungen 

DarkBASIC Quelle: http://de.wikipedia.org/w/index.php?oldid=72300191 Bearbeiter: Aka, Arcanis, Ardo Beltz, Cperrin88, D Man, DangerGround, Elvis untot, Fomafix, Lanna, Lyzzy, M.L, 

MarcoBorn, Maruschka, Nemonand, OttoK, QualiStattQuanti, Speck-Made, Urizen, 15 anonyme Bearbeitungen 

FORTRAN Quelle: http://de.wikipedia.org/w/index.php?oldid=6756105 Bearbeiter: Aka, Alekx, Amoxys, Androl, Arved, Ath, Aths, Bdk, Bhaak, Bierdimpfl, BurghardRichter, Cactus26, 

Cmoder, Daddy Cool, Daniel FR, Daniel Mex, Ddenbrok, Der Hakawati, Diba, Don Magnifico, Eclipse, Fortran-Guru, Gissi, Igrimm12, JCS, Jaellee, Jahobr, JanKorger, Jkbw, Karl-Henner, 

Klausmach, Knorxx, Lars Beck, Leider, Levin, Lichtkind, Marc van Woerkom, Martin-vogel, Matthäus Wander, Mm177, Mvb, Nagy+, Nd, Netzrack.N, Nummer9, Oge, Peter200, Plaicy, 

Polluks, Redf0x, RobertLechner, RokerHRO, SDSchulze, Schnargel, SebastianBreier, Sig11, Sithschi, Stefan Kühn, Tastas, Tobias Bergemann, Tserc, Tuxman, Weialawaga, WilfriedC, 

Winkelmann, Wizzar, ZDragon, Zeichenderzeit, 128 anonyme Bearbeitungen 

FreeBASIC Quelle: http://de.wikipedia.org/w/index.php?oldid=71315324 Bearbeiter: AN, Ae-a, Aka, Allefant, Androl, Ath, Bdk, Blauerflummi, ChristianErtl, Church of emacs, Complex, 

Csderats, D0c, DasBee, DennisExtr, Don Magnifico, Dusky Joe, Euphoriceyes, FB Volta, Filzstift, Florian Weber-alt, Fomafix, Guizza, Habakuk, Jcornelius, Joli Tambour, Kampfmaus, 

Keymaster, Krawi, Krulli, Lichtkind, Markus Böhme, MarkusHagenlocher, Mecki468, MeckiIgel, Michael Reschke, MichaelFrey, MisterD, Mosmas, Okiesp, PC-286, Pelz, PeterFrankfurt, 

Polluks, Priwo, Psygate, RokerHRO, Sarkana, Sascha Brück, Semper, Sinn, Ska13351, Stefan Majewsky, Stefan506, TaPMaN, Tsor, Ttbya, Verwüstung, W!B:, Wort2, 147 anonyme 

Bearbeitungen 

Hallo Welt Quelle: http://de.wikipedia.org/w/index.php?oldid=6987072 Bearbeiter: -Matthäus-, 08-15, 1stMachine, A1000, Abubiju, Ahellwig, Aka, Akribix, Alkab, AllesMeins, Andreas 06, 

Apollo0880, Arbol01, Arne List, Arty, Asteroid7687, Atom3000, Avoided, BSI, Bautsch, Bdk, Benji, Bernard Ladenthin, Blakeks, Boogieman95028, Boris23, Boskoop, Bpascal, Cactus26, 

Candid Dauth, Carbenium, Carstor, Checkup, Chmaas, Chrislb, Christopher Lorenz, Church of emacs, Cliffhanger, Cmoder, Complex, Conny, Crux, D, DangerGround, Daniel B, Dapete, 

DarkwingDE, Das emm, DasBee, Dbenzhuser, Der Ersteller, Der.Traeumer, DerPaul, DeusTron, Diddi, DocSnyder, Don Magnifico, Dsmcg21, Dundak, DutiesAtHand, Dyne, EcKiEsTiEg, 

ErikDunsing, Euku, Felix Stember, Fischchen, Fischi02, Flashenposter, Flogger, Flokass, Fomafix, Freanir, Friesen, Fristu, Fronti, Fschoenm, Fuenfundachtzig, Gail, Gauss, Generalpd, Gismatis, 

Gnu1742, Goldti, Gorko122, Grich, Guandalug, Gunther, HAL Neuntausend, HJPhilippi, HaeB, Hans Bauer, Hardenacke, Haring, HaukeZuehl, Haun, Head, Hella, Herr Th., Hholzgra, Hmilch, 

Hokanomono, Holger I., Howwi, Hubi, Huha, Hutty, Hweihe, Hydro, IGEL, J.C.Denton, JCS, JD, JPB, JaBernet, Jackalope, Janneman, Jed, Jello, Jergen, Jodoform, Johannes2, Jpp, Jörg 

Knappen, K0nze, KL47, Kadeck, Kajk, Kantor.JH, Karottenreibe, Keil, Kiker99, Killerpinscher, Kloth, Kluecke, Knallkopf, Knorxx, Krischik, Kubieziel, Kungfuman, Kup, Kwer Wolf, 

L.Willms, Landaley, Langec, Larf, Leithian, Levin, Lichtkind, Linkin', Littl, Lobla, Lostintranslation, Lumio, MAK, MGascoyne, MGla, Makkonen, Manuel Strehl, Marcadore, MarianSigler, 

Markus Mueller, Martin Wantke, Martin-vogel, Martin83MZ, Meisterplanlos, Memset, Michael Hüttermann, Michaelsy, MicrosoftSam, Mijanima, MisterD, Mkogler, Mnh, Modran, Molily, 

Morszeck, Mosmas, Mps, Much89, Nb, Nd, Neg, Nert, Nolispanmo, Norbert Glauner, Novox, Nux, Oberlaender, Ocrho, Onoxegy, PDD, PatriceNeff, PcPasi, Pcgod, PeeCee, Peter200, 

PhilippWeissenbacher, Pietz, Plaicy, Planegger, Polarlys, Poldi, Polluks, Primus von Quack, Priwo, Profmaad, Prometoys, Psypath, R2C2, RAFPeterM, Ralf Roletschek, Ralf99, Rax, Raymond, 

Rdb, Redfrettchen, Reinerh, Reinhard Kraasch, Rgg, Ri st, Richan, Richardigel, RoadsterDirk, Roger Zenner, Roland2, RolandIllig, Rs newhouse, Rtc, S.K., S.kapfer, SK-Genius, STBR, Salzach, 

Sbeyer, Scared, Schaengel89, Schlesinger, Schmiddtchen, Schnargel, Self, Semiliki, Semper, Seth Cohen, Sevenfifty, ShiKai, Sicherlich, Siehe-auch-Löscher, SilverSrv, Sinn, Sirmoloch, 

Skriptor, Slomoman, Snert, Spid, Spuerhund, Srittau, Stefanp, Stern, StillesGrinsen, Stoerte, Stw, Suchenwi, SuperFLoh, Sven-steffen arndt, Szs, TableSitter, Testudo Aquatilis, Tethys, Teutates, 

TheK, ThePeritus, TheWinner, Theghaz, Thgoiter, Thom, Tian, Tobi B., Tobias Bergemann, TobiasHerp, Tobiask, Tpeuss, Trainspotter, Trebla01, Trublu, Tuetechips, Unscheinbar, Valdachim, 

Viperb0y, Vlado, WIKImaniac, WalterSpiegel, Wdwd, WiESi, Wiegels, Wikipediaphil, Wiktator, Wurzeldrei, XJamRastafire, Xqt, YourEyesOnly, °, 633 anonyme Bearbeitungen 

Java (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=72307003 Bearbeiter: -jha-, 1000の言葉, 130.60.153.xxx, A11158, A1e DE, AF666, AWendt, Achermann, 

Achim Raschka, Afrank99, Aka, Alicante1986, Almdudla, Andre Engels, Andreas lenz, Andrsvoss, Ardo Beltz, Asarion, Ataxa, Ath, Axji, BK, Baikonur, Bartscht, Bastie, Ben-Zin, Bernard 

Ladenthin, BertholdWagner, Bildungsbürger, Bitsandbytes, Boris23, Bullpup, Buntfalke, Carlo Lupo, Carter666, CengizS, Chaddy, Cheeder, Christi4nK, ChristianErtl, ChristianHujer, Chrkl, 

Church of emacs, CommonsDelinker, Complex, Conversion script, Crux, D, DaB., Dachris, DanielSHaischt, Das Ed, Dedi, Deicksta, Der uzi, DerHexer, Dertoradium, DeusTron, Dewars82, 

Diba, Dishayloo, Dnaber, DocSnyder, Dr.Inform, DrPepper, Dralon, DreadVenturous, Duesentrieb, Dunkelangst, El Conde, Elian, Elya, ErikDunsing, ErnstRohlicek, Euklid23, Euku, Fast.ch, Fcc 

go, Felix Stember, FerdiBf, Fgb, Fire, Fisch, Flogger, Florian Keßeler, FlorianN, Fomafix, FrankDopatka, Fred Stober, Friedrich Braune, Frog, Frosty79, GNosis, GeorgGerber, Gil, Gnu1742, 

Golgol, Gorp, Gravitex76, Grebsnork, Gum'Mib'Aer, Gut informiert, HHK, Hades, HaeB, Haeber, Hafenbar, Hagbard, Hank van Helvete, Hardenacke, He3nry, Head, Heiko, Heinovh, Hendrik 

Brummermann, Hernani, Herr Schroeder, Hhoffmann, Hirnederl, Hllizi, Howwi, Hubi, ILA-boy, INM, Infernum, InikOfDoom, Inkowik32, Inspectre, Intertorsten, J Schmitt, Janschejbal, Jed, 

JensBaitinger, Jfwagener, Jkbw, Joddel, Jodo, Johann.Uhrmann, Jonelo, Jowereit, Jpp, Kampet, Kaneiderdaniel, Karl-Henner, Kdwnv, Keks, Keyanoo, Kingruedi, Kku, Knallfrosch, Knopper22, 

Knorxx, Koethnig, Kopoltra, Korinth, Koyaanis Qatsi, Kpg, Krawi, Kristjan, Kubieziel, Kurt Jansson, Kurt seebauer, Kühler Grill, LBV-Zivi, Langec, Laubbaum, Lehmi, Leider, Lenny222, 

Leo141, Leon, LittleJoe, LivingShadow, Locked, Lummer, M82RviGaIGbJg, MAK, Ma-Lik, Ma-games.de, Madmandan, MagicMuscleMan, Magnummandel, Magnus, Magnus Manske, Marc 

Schuelper, Mark Nowiasz, MarkusKnittig, Martin Fuchs, Martin-vogel, Matthias Reissner, Matthäus Wander, Maximum, Meph666, Messi, Metalhead64, Michael Hüttermann, MichaelDiederich, 

Michon90, Mike.lifeguard, Mr.atix, Musik-chris, Myr, Nameless, Ncnever, Nd, Necrophorus, Nephelin, NicTheQuick, Nk3000, Nomadhunter, Nospoftombl, Numbo3, Nutzer 2206, OWeh, 

OecherAlemanne, OliD, OliverWeidel, Onoxegy, Ot, P77a, PatriceNeff, Paul Ebermann, PeeCee, Peter200, PeterReut, Philipp Claßen, PhilippWeissenbacher, Phontoras, Pinguin.tk, Pjacobi, 

Polarlys, Polluks, Pph, Priwo, PsY.cHo, Pythagoras1, Racer93, Ralbisser, Raubsaurier, Rauenstein, Raymond, Revvar, Richardigel, Robb, Rohieb, RosarioVanTulpe, STBR, Schmiddtchen, 

Schmidtm, Schr66, Schranziger, Sebastian.Dietrich, Seicke, Semper, Seraphie, Sherlock Holmes, Siegmaralber, SkaMi, Skriptor, Snert, Softeis, Sparti, Speifensender, Spuckey, Spuk968, St.s, 

Stefan Birkner, Stefan Kühn, Stefan h, Stern, Supaari, SuperFLoh, Superwurmi, Syrcro, Sysrq, The Programmer, TheK, Thomy der Genuss, Thornard, Thüringer, Tiago, Tigeryoshi, 

Till.niermann, Tobiask, TomK32, Toyota prius 2, Trac3R, Trockenfisch, Tsor, Ugh, Ukuechle, Ulfl, Ulrich Schiek, Ulrich.fuchs, Uncopy, Unscheinbar, Untitled, Viperb0y, Vogella, WAH, 

WWW MACVENUS DE, Walter.pachl, Warp, Webkid, Weede, WeißNix, WiESi, Wiegels, WikiBene, Wikiroe, Winhistory, WissensDürster, Wolfgang1018, Wondigoma, Www.zunami.at, 

Xflupp, YMS, Yuuki Mayuki, Zahnstein, Zeno Gantner, Zensurgegner, Zinnmann, Zook, p3EE0E91B.dip.t-dialin.net, °°Ben³, 732 anonyme Bearbeitungen 

JavaScript Quelle: http://de.wikipedia.org/w/index.php?oldid=72436823 Bearbeiter: 130.60.153.xxx, 132-180, 21.213.186.195.dial.bluewin.ch, A Ruprecht, ADK, ASM, Abe Lincoln, Abena, 

Acetobacter, Achim Raschka, Aka, Alauda, Anaximander, Andre Engels, Archiv, Armin P., Arno Oesterheld, Arnomane, Asw-hamburg, Autor, Ben-Zin, Benji, Benzen, Bierdimpfl, 

Bitsandbytes, Black-Hole, Blah, Blaubahn, CHRiSNEW, Callidior, Canyousee, Capaci34, Carminox, Choas, ChrisHamburg, Chrisfrenzel, ChristianErtl, Chth, Church of emacs, Cjlpa, 

Codeispoetry, Complex, Conversion script, CyRoXX, D, Dachris, Darklock, Dein Deutschlehrer, Demus Wiesbaden, Deorkdfkierkfietewre, Der.Traeumer, DerHexer, Diba, Docmo, Dominic Z., 

Don Magnifico, Dreeh, Dullnraamer, EWriter, Edoe, ElRaki, Emdee, Empro2, Entlinkt, Ephraim33, Etagenklo, FabianLange, Florian Adler, Fomafix, Frank Jacobsen, FreelancerHamburg, 

Fritzbruno, Frosty79, Fsswsb, Fusselwurm, GNosis, Gary Luck, Gidoca, Gnu1742, Gunk, HJH, Hacker1, HaeB, Haeber, HannesH, Hansbaer, Haplochromis, HardDisk, Harrydeluxe, Head, 

Howwi, Hozro, Hubi, Hzerres, IGEL, IZazen, Jakov, Jergen, Jpp, Jpschober, JuergenL, Kai Pirinja, Kaneiderdaniel, Karl-Henner, Kenny1987, Kjuu, Kku, Konrad F., Krawi, Kubrick, Kurt 

Jansson, LBV-Zivi, Langec, Lehmi, Lewa, Liberatus, Louis Bafrance, M43kS, Marc-André Aßbrock, Marcel Zimmer, Martin-vogel, Mcaviglia, Meister-Lampe, Meister-Mini, Meph666, Messi, 

Micha koller, Moguntiner, Molily, Mstolt, Muck31, Multi io, Myops, Ndieckow, Netspy, Nicolas17, Ninjamask, Novox, Numbo3, Olliminatore, P. Birken, PIGSgrame, Parzi, PatriceNeff, Paul 

Ebermann, Pelzi, PerfektesChaos, Perrak, Peter200, Philonous, Pittimann, Pjacobi, PointedEars, Polluks, Popolfi, Potterfan, Powerstat, PsY.cHo, Pseliger, Q. Wertz, Rbb, Reinhard Kraasch, 

Reinhard16, Remi, Revvar, Ri st, Robert Wünsche, Rohieb, RokerHRO, RolandIllig, S.Didam, S.moeller, S1, Samtrot, Schnargel, Schrepfer, Schwans, Schweikhardt, Scooty, Sebastian.Dietrich, 

Seewolf, Semper, Septembermorgen, Simonsais, Sinn, Slartibartfass, Spuk968, Stefan Birkner, Stefan Mintert, SteveTheGuitarChief, Stfn, Struppi, Sysrq, T. Schmidbauer, Taratonga, TheK, 

Thire, Thogo, Thomas Forster, Till.niermann, Tim Pritlove, Tinloaf, Tix.64, Tobi B., Tobias Bergemann, Tolentino, Tom-99, Trugbild, Ungebeten, Unscheinbar, Ute-s, V.R.S., Vanger, Verita, 

Video2005, Viperb0y, Vjanoschka, Volatile, Vortex98347, Vulture, WAH, Walter Koch, Wanja, Warp, Webrian, Weede, Wiki-observer, WikiCare, Wikieditoroftoday, Wolfgang1018, 

Wondigoma, XRay, YMS, YourEyesOnly, Zeno Gantner, Zollernalb, Zumbo, Λx.x, 522 anonyme Bearbeitungen 

Lua Quelle: http://de.wikipedia.org/w/index.php?oldid=72353699 Bearbeiter: A350, Aditu, Aka, Angerfist92, Ardo Beltz, Armin P., Aule, Bdk, Beelzebubs Grandson, Bernard Ladenthin, 

Bitsandbytes, Centic, ChrFranke, Ckue, Conspiration, Cvk, D, DL5MDA, Daf, Deorma, Edoe, Elya, Erik Streb, Gigammc, Gisteron, Gronau, Gulrak, HV, Harl, Hedwig in Washington, 

Hermannthomas, Horcrux7, Hubi, JRG, Knut, Kuli, Lars73, Larsgrefer, Liberatus, MrChaosCoffee, Nikai, Numbo3, PhilippWeissenbacher, Pindakaas, Polluks, Rbrausse, RolandIllig, Saibo, 

Schweikhardt, Skypher, Sprezzatura, Stargaming, Stefan506, StephanGrein, TShilo12, TeesJ, Teves, Trublu, Tsor, Umweltschützen, Wikpeded, Yarin Kaul, 109 anonyme Bearbeitungen 

Objective- C Quelle: http://de.wikipedia.org/w/index.php?oldid=72323892 Bearbeiter: Amin Negm-Awad, Ardo Beltz, Bernard Ladenthin, Bhaak, Boecko, Centic, D, Dagobert Drache, Dawn, 

Flone, Fuzzile, Global667, Gronau, HRoestTypo, IOOI, Jobi, JoeDante, Jpp, Jtanzler, Karl-Henner, Kay.loehmann, Kiezkind, Kingruedi, Knorxx, Kockster, Lace, Leider, Lenny222, Lichtkind, 

Liebeskind, LukasHetzi, M2b, Magnus, Marc van Woerkom, Markus Fleck-Graffe, MarkusHagenlocher, Maximum, Mnh, Morszeck, Mpeylo, Nac Mac Feegle, Nasir, Nephelin, Netspy, Oefe, 

Philipp Sªsse, Pingi, Plasmagunman, Polluks, Ratopi, Rbb, Revolus, Revvar, Richardigel, RokerHRO, Sarkana, Schnargel, Sibarius, Stefan Hintz, Stefan.hintz, Succu, Texec, Tom9811, TomK32, 

Traroth, Trustable, TwoThe, Warp, WeißNix, Wiegels, 123 anonyme Bearbeitungen 

Pascal (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=71926803 Bearbeiter: 130.60.153.xxx, AKFoerster, Ahellwig, Aka, Alexander.stohr, Andre Engels, Arbol01, 

Ath, Avatar, Avoided, Baba66, Ben-Zin, BerndGehrmann, Blaubahn, Cactus26, Carol.Christiansen, Charmion, Cjesch, Clusterfuck, Complex, Conversion script, Curtis Newton, Cyper, D,


D0ktorz, Danny243, DerPaul, Diba, Doktor Datentod, Don Magnifico, Dp99, Dr.tux, Echoray, ErhardRainer, Fabian7351, Flo 1, Flothi, Fomafix, Freak 1.5, Gce, Georg Peter, Gms, Gnu1742, 

Gnushi, Gronau, Gurt, HaSee, He3nry, Hermannthomas, Herzschritt, Hubertl, Implementation, Irrgärtner, Jed, Jens Beckmann, Joho345, Jonelo, Jutta234, Jwdietrich2, Jörg Knappen, 

Karl-Henner, Karlscharbert, Kingruedi, Klxtctc, Knoerz, LKD, Leider, Leithian, Liberatus, Lofote, Lupenrein, Lupinoid, Lustiger seth, MAK, MGla, Magnus, Marcus Cyron, MarkusKnittig, 

Martin-vogel, Matthäus Wander, Mh, Miriel, Mps, Muck31, NaHSO4, Neg, Nephelin, Onee, P. Birken, PDCA, PDD, Paddy, Pelz, Peterlustig, Philipendula, PhilippWeissenbacher, Polluks, 

Ralf5000, Ri st, S.Didam, Saemikneu, Sargoth, Schaelss, Schreibvieh, Shiyaki, Siego, Sinn, Soebe, SonniWP2, Staro1, StefanRybo, Steffen, Steschke, T34, TheK, TheTruth90, Thomas Stauß, 

Thomas W. Mueller, Thüringer, Tim, Trustable, Umtrunk, Unscheinbar, Waelder, Warp, Webkid, Wirthi, Wkrautter, Wuzel, Xilef, Xqt, Zebbo, gw.phinware.de, lodoss.inf.ethz.ch, 

p3EE045A9.dip.t-dialin.net, pD9009835.dip.t-dialin.net, 236 anonyme Bearbeitungen 

PEARL Quelle: http://de.wikipedia.org/w/index.php?oldid=53985695 Bearbeiter: Abdull, Ath, Avatar, ChristophDemmer, Crux, Gnu1742, Haeber, Hholzgra, J. 'mach' wust, JCS, Jed, Jutta234, 

Lantash, Lichtkind, M.Marangio, Melancholie, Nightwish62, Polarlys, Polluks, Raupach, Thornard, Tom md, Weissbier, YMS, 14 anonyme Bearbeitungen 

Perl (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=72254632 Bearbeiter: 217, 2Bios, 5gon12eder, AF666, AFBorchert, AcE, Achim Raschka, Ahellwig, 

Ahnungsloser, Aka, Akermit, Akz, Alauda, Alexander.stohr, Alexh, Anschroewp, Apulix, Arbec, Aschmidt, Avatar, BLueFiSH.as, Ballapete, Beauty, Benni Bärmann, BerndB, 

BernhardSchmalhofer, Berni, Betterworld, Bhaak, Blaufisch, Brf, Brion VIBBER, Btr, Caky, Centic, Chrisfrenzel, ChristianErtl, ChristianHujer, ChristophDemmer, CommonsDelinker, Complex, 

Conversion script, Cspan64, D, D0ktorz, Daniel Mex, DarkDust, Das emm, Diba, Dnaber, Dohndorf, Dominik, Dralon, Edao, Ekuah, El Cazangero, Electrocat, Emdee, Endorphine, Erusx, 

Eserte12, Esky212, Etagenklo, Firebat, Florian, Fomafix, Fretchen1, Fw, Gedeon, GeeF, Gfis, Guandalug, Gubaer, Gunther, Gurt, Gurumaker, HAL Neuntausend, HHK, HaSee, Hadibe, Haeber, 

Head, Heinte, HenrikHolke, Hernani, Herr Th., Herzrein, Hubi, Hydro, Iblech, Iblue, Ilja Lorek, Itangast, Ixitixel, J. 'mach' wust, JPense, Jaellee, Jailbird, Jed, Jens Meißner, Jergen, Johannesl, 

Joli Tambour, Jonelo, Jumbo1435, Jutta234, Jörg Knappen, JøMa, Karl-Henner, Kasper4711, Kek00207, Kiker99, Konrad F., Krischan111, Kubieziel, Kuli, Kurt Jansson, Langec, Ldi91, Lehmi, 

Leipnizkeks, Leit, Leithian, Lichtkind, MFM, MGla, Ma-Lik, Magnus, Malteser, Marc van Woerkom, Marcus Schätzle, Markus.oehler, Martin-vogel, Matt1971, Matthäus Wander, MattiasS, 

Media lib, Melancholie, Merkel, Messi, Mezzofortist, Micha koller, MichaelFrey, Mijobe, Mnh, Moritz Lenz, Mosmas, Mps, MrTux, Mwka, Mx2000, Nalpdii, Nef, Nephelin, Neufra, Ninjamask, 

Nolispanmo, Ocrho, Ollinaie, PIGSgrame, Papiermond, Pasc2, PaterMcFly, Pddywnger, Peddn, Pelz, Perlentaucher, PhilippWeissenbacher, Phrood, Pinguin.tk, Polarlys, Polluks, Poupou 

l'quourouce, Priwo, Qualito, Quetzalcóatl, Ramiro, Raphael Frey, Raubsaurier, Reaper35, Reiskocher, Renekaemmerer, Ri st, Rl, RoBri, RobertLechner, RokerHRO, Roland2, Rupp.de, 

STEFFENW, Schaengel89, Schnargel, Schusch, Schweikhardt, Seewolf, Siúlóir, Slartidan, Sleske, Sohin, SoniC, Specht, Speck-Made, Stan 78, Staro1, Steevie, Stefan Kühn, Stefan Majewsky, 

Stefan h, StefanAndres, Sunks, Sven423, Svetho, Tashbarg, Tels, TheK, ThePeter, Theomega, Theoprakt, Thornard, Thüringer, Tim, Tinita, TobiasHerp, Trac3R, Trustable, Tschild, Tsor, Ttbya, 

Ttobsen, Tullius, Tönjes, UV, Uellue, Uncopy, Uwe Hermann, Vanger, Wahrerwattwurm, Wasserseele, Weisbrod, Wer8olf, Wgeorg, Wiegels, Wikiplex, Wiktator, Wondigoma, Wrongfilter, 

Wutzofant, XTaran, Xidimax, Xwolf, Zeno Gantner, Zu7, Zumbo, Zupftom, 502 anonyme Bearbeitungen 

PHP Quelle: http://de.wikipedia.org/w/index.php?oldid=72408555 Bearbeiter: -jha-, 217, A.hafner, Abe Lincoln, Abubiju, Achim Raschka, Acrux, Aka, Akl, Akorczak, Alarm fuer die galaxis, 

Alexander Brock, Alti, Andreas von Oettingen, Apricum, Ar291, ArminRonacher, ArschMitOhren, Arty, Athalis, Augiasstallputzer, Aule, Avoided, Awacs, BG11A, BLueFiSH.as, Bachsau, 

Bahnemann, Barpfotenbaer, Bbestmann, Benefix, Benji, Bernard Ladenthin, Bernd vdB, Bernd89, Biktora, Birnkammer fabian, Bitsandbytes, Björn Bornhöft, Blaufisch, Boonekamp, Breeze, 

Brian johnson, Burnz, C167, Caramdir, Chatfix, Chlämens, Chris828, Christian Müller, Christoph Pojer, Ckeen, Ckendel, Clemfix, Cocoun, Complex, Conversion script, Corvin Gröning, Cvk, 

Cybercraft, D, D0ktorz, Da ola, DaSourcerer, Dachris, DangerGround, DasBee, Deever, Delete, Dentastic, Der Wolf im Wald, Der.Traeumer, DerHexer, DerSchnüffler, DeusTron, Diba, Djotrim, 

Dnaber, Dodo von den Bergen, Dominic Z., Dominik, Drf, Druffeler, Dundak, Dutch damager, Eichhornleib, Engeser, Engie, Entlinkt, Euphoriceyes, Eurolo, EvaK, Evilboy, FFSquall, Fafer, 

Fester franz, Filzstift, Finex, Fire, Fleshgrinder, FloSch, Flotsam, Flups, Flurfunker, Fomafix, Frank C. Müller, FreelancerHamburg, Friedels-home.com, Fristu, Fritz Grimpen, Fritz Jörn, FritzG, 

Fstoertz, FutureCrash, Gauss, Gavin Mitchell, Generalpd, GeorgGerber, Gerald Zincke, Gilliamjf, Gronau, Gunk, Gurt, Gurumaker, H3ir, Haeber, Hannes Trink, Hannsest316, Hardenacke, 

HeWö, Head, Hello111, Hendrik Brummermann, Herr Th., Hinrich, Hmilch, Hoo man, Houbsi, Howwi, Hubi, Hummelblau.de, Hydro, Hypersmil, IGEL, ISkriD, Iblue, Igelball, Igrimm12, 

Impulz, Ingmar R., Inschanör, Int80h, Ipgehtnicht, J.Sauer, JAF, JLG, Jarling, Jed, Jens Kohl, Joli Tambour, Joliver, Jonathan Hornung, Josef Spindelböck, Jowi, JuergenL, Jörg Kopp, Kai 

Wasserbäch, Kai-Hendrik, Karl-Henner, KeineAhnung1337, Kevin dersum, Kevinin, Kh555, KingCrunch, Kintaro221, Klauseck, Klever, Kloeschen, Knoedel, Kolossos, Krawi, Kubieziel, 

Kubrick, Kurt Jansson, Kurt seebauer, Kvn, LKD, Langec, Langnickel, Lares0, Lehmi, Leipnizkeks, Lew, Libro, Lichtkind, Lmh, Longamp, Louisharms2, Löschfix, MFM, MaKoLine, Madokan, 

Maelcum, Magnummandel, Magnus, Malkusch, Mannerheim, Manni88, Marco Bockelbrink, Marian.sigler, MarkGGN, Marti95., Masterbrain, Matthäus Wander, Mattog, Meph666, 

MichaelDiederich, Mijozi, Mikepowers, Misery, MlaWU, Mnh, MoLa, Mononoke, Morget, Morten Haan, MovGP0, Mpils, Mstolt, Mugros, Murph, Mwka, My name, Nasir, Neakro, Neil Hilist, 

Netspy, Neverything, Nick-less, Nikkis, Nolispanmo, Noobsrai, Norro, Nrieck, Numbo3, OecherAlemanne, Okuhl, Olei, Olemo, Ollinaie, Pascal Bajorat, Pascalhurni, PatriceNeff, Patrick Paas, 

Pberndt, PeeCee, Pelz, Perlentaucher, Peter200, Petkli, PhilippWeissenbacher, Phulab, Pkn, Pne, Polarlys, Progman, PsY.cHo, Qualle, Querverplänkler, Quirin, RBQ, Rainer Wasserfuhr, Raphael 

Haase, Raymond, Rbe, Reinhard Kraasch, Revvar, Rikumaster, Roerd, Rohieb, Roland Kaufmann, Roland2, Roterraecher, S1, S4V4Ge, Sansculotte, Sappy, Sargoth, Scared, Schnargel, Schoegy, 

Schubbay, Schwarzweiß, Seewolf, Semper, Senshi, Simon-Martin, Sinn, Sintonak.X, Skicu, Slomoman, Snapper007, Solid State, Southpark, Speifensender, Staro1, SteBo, Steef389, Stefan, 

Stefan Kühn, Stefan Majewsky, Stefan Schultz, Stefan506, Stefreak, Stephan Herz, Stern, Suit, Sunks, SvPe, Sven-steffen arndt, Sven423, Sys.Bak, Tajbender, TheK, Theyak, Thomas.gutbier, 

Thüringer, Tian, Tilman Berger, Tilo Körner, Timohummel, Timtaler, TinoTischer, Tjö, To.ni, Tobi B., Tobi91, TobiasHerp, TobiasNYC, Tobiask, Togs, TomK32, Tomx992, Tony L., 

Torsten.Stefan, Traroth, Trustable, Tsor, Tsukasa, Tönjes, Uellue, Unscheinbar, UrLunkwill, Ute Erb, Vanger, Ventrue, Wanzo, Warhog, Webmeischda, Werbeagentur-Schnüffel, Wiegels, 

WikiPimpi, Wilhans, WissensDürster, Wittkowsky, Woodworker, Wst, Wuzur, Wynk, XT3000, XTaran, YMS, Yarin Kaul, Yellowcard, YourEyesOnly, Zahnstein, Zaphiro, Zumbo, 

gw.phinware.de, 817 anonyme Bearbeitungen 

Profan (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=53543621 Bearbeiter: A Ruprecht, Aka, Beck's, Bernard Ladenthin, CF2, Cactus007, Complex, Ephraim33, 

Fomafix, Frabbing, Frank Murmann, Howwi, Hummelblau.de, IF, Jutta234, Kuhlo, Mhp1255, Nordwind64, Schnatzel, Sd5, Timosch, WortUmBruch, 45 anonyme Bearbeitungen 

PureBasic Quelle: http://de.wikipedia.org/w/index.php?oldid=71315485 Bearbeiter: Andesdaf, Antonsusi, Ardo Beltz, Benpicco, Blitzbat, Boemmels, Brodkey65, ChrisHamburg, Chrisfrenzel, 

D, DangerGround, DasBee, Dealerofsalvation, Echoray, Exil, Gardini, Guandalug, Hroudtwolf, Inkowik32, Karl Nickel, Koerpertraining, Kombble, Langec, MarcoBorn, Martin Aggel, Mh, 

Mikenolte, Mknjc, Mr. Anderson, Nonanet, PDD, Pelz, Pischdi, Polarwolf.eu, Robert Wünsche, RobertLechner, S.K., STBR, SimonSimCity, Sinn, Sovok, Spacecaptain, Traitor, Tschäfer, 

Tönjes, Wolle212, Xls, ZettaMe, 127 anonyme Bearbeitungen 

Python (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=72469978 Bearbeiter: 5gon12eder, AF666, AWak3N, AZH, Aetas volat., Aka, Alexander.stohr, Alexian, 

AlfonsGeser, Amgon, Andreas aus Hamburg in Berlin, AndreasB, AndreasSchreiber, Ardo Beltz, ArminRonacher, Badger, Baloghandris, Ben-Zin, BercherP, Bernd vdB, Bitsandbytes, Blackbird, 

Blauebirke, Blinry, Boemmels, Bronger, C-logic, CIMMA, Callidior, Carlolf, Carſten, Cghost, ChrisHamburg, Chrislb, Christian2003, Chsterz, Ckahrs, Ckeen, Contributor, D, D0ktorz, Dapete, 

Das Gurke, DasBee, Der Messer, DerAnalyst, DerHexer, Dilettant, Dishayloo, DoBu, Doener1, DonKult, Dracman, Drbashir117, Dwi Secundus, E-Malte, Edoe, Eehmke, Elvis untot, 

Enth'ust'eac, ErikDunsing, Fbahr, Felanox, FelixP, Fire, FischX, Fkoch, Flindner, Flogger, Fomafix, Fragment, Frank78, FutureCrash, Ghisguth, Gnushi, Gronau, Gs93, Gurt, Haeber, Harald 

Tribune, He3nry, Head, Heinrich Puschmann, Heliozentrik, HenHei, Herr Th., Herrick, High-Fish, Homer Landskirty, Hubertl, Hubi, Hugels, Hydro, INM, ITMönch, Ich hab hunga, J. 'mach' 

wust, J.Ammon, JWN, Jaan, Jan Giesen, Janneman, Jens Lallensack, Jfieres, Johann.Uhrmann, Jorges, Jutta234, Kackwurst, Kai-Hendrik, Karl-Henner, Kheinisch, Kku, Klaeren, Klemens 

Winter, Kn0rke, Knorxx, Koelnerbinchen, Kopoltra, Krille, Kubieziel, Kurs 2010, Kurt Jansson, Kurt seebauer, Langec, Levin, Lichtkind, LoKiLeCh, LukasHetzi, Lukian, Löschfix, MGla, Marc 

van Woerkom, Marco Krohn, Marcus Schätzle, Markus.schulze, Martin-vogel, Mathias Schindler, Matthias Kupfer, Matzematik, Melancholie, Michael Meier, Michael Reschke, MichaelB., 

Mig-O, Milanx, Mjoppien, Modn, Muck31, MusiKk, Musik-chris, Mvo, Mx2000, My name, Nachtigalle, Nankea, Napa, Nd, Nephelin, Nerd, Nikai, Nocta, Nolispanmo, Ocrho, Oefe, Ohno, 

Olliminatore, Pemu, Peter200, PhilippWeissenbacher, Phrontis, Phrood, Pilawa, Pjacobi, Pokernikus, Polarlys, Priwo, Prometheus89, Prowal, Pydo, Python-Clown, RabbitsDad, 

Radikal.reduziert, RalfZosel, Raphael Frey, Rat, Rbb, Red Rooster, RedMars, Retfah, Revvar, Robin Stocker, Roland2, Rs2411, S!ska, S1, SK-Genius, Sansculotte, Sbeyer, Schweikhardt, 

Semper, SilP, Simon04, Snert, Sol1, Sprezzatura, Sputnik, Stauba, Stefan Kühn, Stefan64, Steffen, Stern, Stw, Stylor, SuperFLoh, Svens Welt, Tafkas, Template namespace initialisation script, 

TheK, Theoprakt, Thornard, Thüringer, Tismer, TobiasHerp, Tom82, Trac3R, Trockenfisch, Trustable, Tsor, Tsukasa, Tullius, Umeier, Uncopy, Ungebeten, Vanger, Viruzz, WStephan, 

Weialawaga, Wesener, WiESi, Wiegels, Wikpeded, Wiska Bodo, Wrongfilter, Wurstwolf, X2on, Xorx77, Xsteve, YMS, YourEyesOnly, Zagy, Zeno Gantner, Zorak1103, °, 330 anonyme 

Bearbeitungen 

REALbasic Quelle: http://de.wikipedia.org/w/index.php?oldid=70546254 Bearbeiter: AHZ, Achates, AndreasPrang, Christian Sakowski, Complex, CosmoJasra, Dauerbaustelle, Dickerchen, 

Fast.ch, Felix Krause, HaSee, Ignatius Segensreich, Istandil, JD, Jens Meißner, Jutta234, Marcel Zimmer, Marcgeldon, Memex, Mnh, Moeppel64, Morszeck, Mps, Overbenny, Polluks, 

RobertLechner, S.K., Steffen, Tönjes, Urizen, Www.capitalcorner.de, 22 anonyme Bearbeitungen 

Ruby (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=70900089 Bearbeiter: *p-marc, --, Aka, Aldawalda, AndreasSchwarz, Athalis, BKSlink, BeatePaland, 

Ben-k86, Benjie Maus, Bhaak, Bierdimpfl, Blauebirke, Blinry, C3o, Cactus26, Chol, Chricho, ChristianBier, Cirr, D, D0ktorz, Daniel Bovensiepen, DanielSHaischt, Das emm, DerHexer, Dwi 

Secundus, Ecki, Erkan Yilmaz, FF-Wonko, Fandorin, Flappaport, Flogger, Flominator, Fomafix, Fristu, FutureCrash, Gissi, Gnu1742, Gurt, HALsixsixsix, HHK, Hador, Haize, Hcy, Head, 

Heilbron, Hurone, Hydro, IGEL, Ich hab hunga, JCS, Jed, Jens Meiert, Johnny Slogan, Josef 'Jupp' Schugt (aka 'Penpen'), Jpp, Karl-Henner, Kiker99, Klausb, Knub.nafets, Kubieziel, Kurmis, 

Lenny222, Levin, Lichtkind, Loupram, Martin Hampl, Media lib, Meph666, Messi, Mikue, Mr. Anderson, Muck31, Murphy the crow, Nachtigalle, Nephelin, Netzki, Nikai, Nockel12, Onee, 

Otih, Ozuma, PeeCee, Pendulin, Philipendula, Philipp Claßen, Pjacobi, QualiStattQuanti, Ralf5000, Revvar, Richardigel, Rt73, S.kapfer, SBraun, Sbeyer, Schaengel89, Sicherlich, Spazion, 

Sprezzatura, Stefan Kühn, Stefan h, StephanGrein, Stern, Teqsun81, TheK, Thinkdiv, Thüringer, Timcn, WiESi, Wiegels, Wikiwikigreif, Winfried Mueller, Wst, Xaphir, Xqt, Yamavu, Zeno 

Gantner, Zwoenitzer, 210 anonyme Bearbeitungen 

Smalltalk (Programmiersprache) Quelle: http://de.wikipedia.org/w/index.php?oldid=21003529 Bearbeiter: 3.141.186.195.dial.bluewin.ch, Abe Lincoln, Aka, AndreasB, Andrush, Archiv, 

Arved, BeeJay, Ben-Zin, Bierdimpfl, Blauebirke, Blinry, Boemmels, Brion VIBBER, ChristianErtl, Conversion script, D, DanielSHaischt, Don Magnifico, Drumknott, Duesentrieb, El capitan,


Ephraim33, ErnstRohlicek, Fleminra, Flo 1, Flogger, Fomafix, Fristu, Georgheeg, Guandalug, HannesH, Head, Heinte, Hytrion, JRG, Jekub, Jpp, Jst brd, Kaktus, Kallistratos, Kdkeller, Knoerz, 

Kpjas, Kubieziel, Kuli, Kurt Jansson, LargoAreno, Liebeskind, Lukian, Magnus, Marcelglaeser, Matumio, Melkom, Memex, MibiMoon, Michael Balzer, Mkleine, Mtwoll, Nicky knows, 

Nikolaus, Nolispanmo, Paul Ebermann, Pingi, Pinguin.tk, Pit, Rbb, Richardigel, RoKo, RokerHRO, Rolf b, STBR, Sbeyer, Schaengel89, Softeis, Speedy DeLete, Spuk968, Stargaming, Stefan 

Kühn, Steffenjung, Stern, Stowasser, SuperFLoh, Terabyte, Tönjes, Uwe Gille, Vinci, Vulture, Walter, Walter Koch, Wilfried Elmenreich, Wst, Xflupp, Zeno Gantner, °, 160 anonyme 

Bearbeitungen 

Turbo Pascal Quelle: http://de.wikipedia.org/w/index.php?oldid=72465008 Bearbeiter: Avh, BLueFiSH.as, Ben-Zin, Burkhard L, Ce, Chrisfrenzel, Croco97, D, Daniel Seibert, DasBee, Don 

Magnifico, FGodard, Fakemailer, Flattervieh, Flups, FutureCrash, Gerold Broser, Get It, HAL Neuntausend, Haize, HartmutS, Henning Ihmels, Highbrow, Himuralibima, Hubertl, Hukukçu, 

Jaguarkid, Jed, Joschi71, Jpp, Kickof, King, Krawi, Laza, LoKiLeCh, Longamp, MarkusHagenlocher, Mps, Mvb, Nephelin, Nyxos, Olei, OttoK, PDD, Peterlustig, Phil1987, Phrontis, Pkn, 

Plaicy, RFranssen, Ralf5000, Redeemer, Rehro, Revolus, Septembermorgen, Sinn, Steffen, Thomas W. Mueller, Tors, Tritonus05, Tönjes, Ungebeten, Wzwz, Yokokokon, YourEyesOnly, Zeno 

Gantner, 113 anonyme Bearbeitungen 

Visual Basic Quelle: http://de.wikipedia.org/w/index.php?oldid=71554830 Bearbeiter: Ahellwig, Aka, BSDev, Baumfreund-FFM, Behalten, Bernard Ladenthin, Björn Bornhöft, Blaubahn, 

Boonekamp, C.Wesner, Chaddy, Chesk, Chiccodoro, ChristianGlaeser, Coaster J, Complex, Cypressious, DasBee, Dewars82, Diba, Don Magnifico, DrSoong, Dundak, Engie, Ento, Etix, 

Eulenjäger, Euphoriceyes, Ferdinand f., Filzstift, Florian Sening, Fomafix, Fox21, Frank Murmann, Gerbil, Goldener Kater, Guenter47, Hans Genten, Hans Koberger, Heinzi.at, Hozro, Hubertl, 

INM, Ifm, Jackalope, Jan-Rainbow, Jens m0, Jergen, Joschi71, Jost Riedel, Jpp, Koelnerbinchen, Konrad F., Krawi, Kww, LKD, Leithian, Lemzwerg, LonelyPixel, Ma-Lik, Mark553, Mnh, My 

name, Nddsf, Nixsager, Nolispanmo, OHM-9, Opethmaniac, Pc-world, PeeCee, Peter200, QualiStattQuanti, Regi51, Reptilologe, Rita2008, RomanLatosik, STBR, Seewolf, Stammtisch, Stefan 

Majewsky, Strecke, Streifengrasmaus, TableSitter, ThunderBlaze, Tolentino, Trustable, Tönjes, Umweltschutz, WAH, Wms15, YMS, Zaphiro, Михајло Анђелковић, 171 anonyme 

Bearbeitungen 

Esoterische Programmiersprache Quelle: http://de.wikipedia.org/w/index.php?oldid=71801665 Bearbeiter: Achim Raschka, Aka, Arbol01, BKS-Ordner, Citizen, Crux, D, Das .:X, Dolos, 

Duesentrieb, Euku, Frakturfreund, FrankBuss, GDK, Gerhardvalentin, GodsBoss, Inschanör, Jonathan Hornung, Kubieziel, Lextard, Lichtkind, Lx, Maynard, Mnh, Mo4jolo, Nina, Nivram, 

Phrood, Rax, Reeno, Rs newhouse, Sascha.leib, ShiKai, Sir Anguilla, TheBug, Tsor, Tuxman, Tzzzpfff, Ulrich.fuchs, Wertzumteufl, WilhelmHH, Xqt, Zone42, 51 anonyme Bearbeitungen 

Brainfuck Quelle: http://de.wikipedia.org/w/index.php?oldid=71516876 Bearbeiter: Achim Raschka, Adokhugi, Alex42, Arbol01, Balaklava, Bender235, Bernhard-h, Björn Bornhöft, 

Capaci34, Choas, Christian2003, Citizen, Crux, DasBee, Dishayloo, Duesentrieb, Eike sauer, Elvis untot, Eradest, Euphoriceyes, EvaK, FelixN, Fgb, Fomafix, GNosis, Generalpd, Gerd 

Taddicken, HaSee, Harald Tribune, Homer Landskirty, Horas, IGEL, Igge, J budissin, Jacks grinsende Rache, Jfwagener, Joerg s, Johannesbauer, Jpp, Karl-Henner, Kiker99, Koethnig, Kopoltra, 

LKD, Laza, Lichtkind, Lummer, Lx, Magnus, Maxliebscher, Mcreichelt, Mijobe, Miriel, Mkleine, Morsix, Nagasaki, Nikai, Norro, Oktaeder, PDD, Peter200, Philipendula, Phrood, Polarlys, 

PowPit, RAFPeterM, Rafl, Rdb, Reinhard Kraasch, Roger Zenner, RokerHRO, RolandIllig, RosarioVanTulpe, Schnulli00, Smeyen, Stefan Majewsky, Stefan64, Stefanp, Suchenwi, T.D.Rostock, 

Taisa, Tengai, TheBug, TheReincarnator, Thornard, Thyâlae, Timwi, Tischlampe, Tripwire, Tsor, Tuxman, Tzzzpfff, Unscheinbar, Uwe Gille, V.R.S., VanGore, Video2005, Vigilius, Weede, 

WiESi, WissensDürster, Wolle212, Wsombeck, Xororand, Zap, 百科全書, 137 anonyme Bearbeitungen 

Brainfuck2D Quelle: http://de.wikipedia.org/w/index.php?oldid=44212227 Bearbeiter: Achim Raschka, Adokhugi, Alex42, Arbol01, Balaklava, Bender235, Bernhard-h, Björn Bornhöft, 

Capaci34, Choas, Christian2003, Citizen, Crux, DasBee, Dishayloo, Duesentrieb, Eike sauer, Elvis untot, Eradest, Euphoriceyes, EvaK, FelixN, Fgb, Fomafix, GNosis, Generalpd, Gerd 

Taddicken, HaSee, Harald Tribune, Homer Landskirty, Horas, IGEL, Igge, J budissin, Jacks grinsende Rache, Jfwagener, Joerg s, Johannesbauer, Jpp, Karl-Henner, Kiker99, Koethnig, Kopoltra, 

LKD, Laza, Lichtkind, Lummer, Lx, Magnus, Maxliebscher, Mcreichelt, Mijobe, Miriel, Mkleine, Morsix, Nagasaki, Nikai, Norro, Oktaeder, PDD, Peter200, Philipendula, Phrood, Polarlys, 

PowPit, RAFPeterM, Rafl, Rdb, Reinhard Kraasch, Roger Zenner, RokerHRO, RolandIllig, RosarioVanTulpe, Schnulli00, Smeyen, Stefan Majewsky, Stefan64, Stefanp, Suchenwi, T.D.Rostock, 

Taisa, Tengai, TheBug, TheReincarnator, Thornard, Thyâlae, Timwi, Tischlampe, Tripwire, Tsor, Tuxman, Tzzzpfff, Unscheinbar, Uwe Gille, V.R.S., VanGore, Video2005, Vigilius, Weede, 

WiESi, WissensDürster, Wolle212, Wsombeck, Xororand, Zap, 百科全書, 137 anonyme Bearbeitungen

Quelle(n), Lizenz(en) und Autor(en) des Bildes 197 

Quelle(n), Lizenz(en) und Autor(en) des Bildes 

Datei:Listing1.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Listing1.jpg Lizenz: Public Domain Bearbeiter: Grandy02, Joho345, 1 anonyme Bearbeitungen 

Datei:Icon falscher Titel.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Icon_falscher_Titel.svg Lizenz: Public Domain Bearbeiter: User:Madden 

Bild:Fblogo.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Fblogo.gif Lizenz: GNU Free Documentation License Bearbeiter: Allefant, Michael Reschke 

Image:FBIde 0.4.6.png Quelle: http://de.wikipedia.org/w/index.php?title=Datei:FBIde_0.4.6.png Lizenz: GNU General Public License Bearbeiter: Michael Reschke 

Datei:Piet Program Hello World(1).gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Piet_Program_Hello_World(1).gif Lizenz: Creative Commons Attribution-Sharealike 3.0 

Bearbeiter: User:Mosmas 

Datei:Java-Logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Java-Logo.svg Lizenz: unbekannt Bearbeiter: Afrank99, Jodo, 4 anonyme Bearbeitungen 

Bild:DIN-Logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:DIN-Logo.svg Lizenz: unbekannt Bearbeiter: unbekannt. Original uploader was Afrank99 at de.wikipedia. Later 

version(s) were uploaded by Schnelliboy at de.wikipedia. 

Datei:Larry Wall YAPC 2007.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Larry_Wall_YAPC_2007.jpg Lizenz: Creative Commons Attribution-Sharealike 2.0 Bearbeiter: 

Randal Schwartz from Portland, OR, USA 

Datei:JPL.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:JPL.jpg Lizenz: GNU Free Documentation License Bearbeiter: Horst Frank, Lennert B, Ruslik0, 2 anonyme 

Bearbeitungen 

Datei:Cpan.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Cpan.jpg Lizenz: unbekannt Bearbeiter: Chaddy, Ixitixel, Lichtkind 

Datei:Damian Conway.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Damian_Conway.jpg Lizenz: Creative Commons Attribution 2.0 Bearbeiter: Edward, FlickreviewR, GeeJo, 

Nilfanion, Para, Schutz 

Datei:Tim O'Reilly 2005 Where 2.0 Conference1.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Tim_O'Reilly_2005_Where_2.0_Conference1.jpg Lizenz: Creative Commons 

Attribution 2.0 Bearbeiter: Dodo, Edward, Guety 

Datei:TPF logo.png Quelle: http://de.wikipedia.org/w/index.php?title=Datei:TPF_logo.png Lizenz: unbekannt Bearbeiter: Ixitixel, Lichtkind 

Datei:randal l. schwartz.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Randal_l._schwartz.jpg Lizenz: Creative Commons Attribution-Sharealike 1.0 Bearbeiter: Derrick Story 

Datei:Drei mongolische kamele.JPG Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Drei_mongolische_kamele.JPG Lizenz: Creative Commons Attribution-Sharealike 2.5 

Bearbeiter: User:He-ba-mue 

Datei:PHP-logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:PHP-logo.svg Lizenz: unbekannt Bearbeiter: Biktora 

Datei:PHP funktionsweise.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:PHP_funktionsweise.svg Lizenz: GNU Free Documentation License Bearbeiter: Benutzer:Cactus007, 

Benutzer:MovGP0 

Datei:Purebasic_logo.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Purebasic_logo.gif Lizenz: unbekannt Bearbeiter: Karl Nickel 

Datei:Helloworld-pbx86.png Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Helloworld-pbx86.png Lizenz: unbekannt Bearbeiter: Kombble 

Datei:HalloWeltConsole.jpg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:HalloWeltConsole.jpg Lizenz: unbekannt Bearbeiter: Benutzer:Kombble 

Datei:Pb_ide.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Pb_ide.gif Lizenz: unbekannt Bearbeiter: Karl Nickel 

Datei:Pb_vde.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Pb_vde.gif Lizenz: unbekannt Bearbeiter: Karl Nickel 

Datei:Python_logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Python_logo.svg Lizenz: Trademarked Bearbeiter: www.python.org 

Datei:Ruby logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Ruby_logo.svg Lizenz: Creative Commons Attribution-Sharealike 2.5 Bearbeiter: Yukihiro Matsumoto, Ruby 

Visual Identity Team 

Datei:Yukihiro Matsumoto.JPG Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Yukihiro_Matsumoto.JPG Lizenz: Public Domain Bearbeiter: Cep21 

Bild:Smalltalk-powered.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Smalltalk-powered.gif Lizenz: unbekannt Bearbeiter: ChristianBier, DanielSHaischt, Zeno Gantner 

Datei:turbo1_0.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Turbo1_0.gif Lizenz: unbekannt Bearbeiter: Breeze, Croco97, 1 anonyme Bearbeitungen 

Datei:Turbopascal 6.png Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Turbopascal_6.png Lizenz: unbekannt Bearbeiter: Benzen, Rehro 

Datei:Microsoft NET Logo.svg Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Microsoft_NET_Logo.svg Lizenz: unbekannt Bearbeiter: Frank Murmann 

Datei:Vbdos form.png Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Vbdos_form.png Lizenz: unbekannt Bearbeiter: Ferdinand f. 

Datei:VBDOS_IDE.PNG Quelle: http://de.wikipedia.org/w/index.php?title=Datei:VBDOS_IDE.PNG Lizenz: unbekannt Bearbeiter: Ferdinand f. 

Datei:Wiki.hlp.gif Quelle: http://de.wikipedia.org/w/index.php?title=Datei:Wiki.hlp.gif Lizenz: unbekannt Bearbeiter: Benutzer:Ferdinand f.

Lizenz 198 

Lizenz 

Wichtiger Hinweis zu den Lizenzen 

Die nachfolgenden Lizenzen bezieht sich auf den Artikeltext. Im Artikel gezeigte Bilder und Grafiken können unter einer anderen Lizenz stehen sowie von Autoren erstellt worden sein, die nicht in der Autorenliste 

erscheinen. Durch eine noch vorhandene technische Einschränkung werden die Lizenzinformationen für Bilder und Grafiken daher nicht angezeigt. An der Behebung dieser Einschränkung wird gearbeitet. 

Das PDF ist daher nur für den privaten Gebrauch bestimmt. Eine Weiterverbreitung kann eine Urheberrechtsverletzung bedeuten. 

Creative Commons Attribution-ShareAlike 3.0 Unported - Deed 

Diese "Commons Deed" ist lediglich eine vereinfachte Zusammenfassung des rechtsverbindlichen Lizenzvertrages (http:/ / de. wikipedia. org/ wiki/ Wikipedia:Lizenzbestimmungen_Commons_Attribution-ShareAlike_3. 0_Unported) 

in allgemeinverständlicher Sprache. 

Sie dürfen: 

• das Werk bzw. den Inhalt vervielfältigen, verbreiten und öffentlich zugänglich machen 

• Abwandlungen und Bearbeitungen des Werkes bzw. Inhaltes anfertigen 

Zu den folgenden Bedingungen: 

• Namensnennung — Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. 

• Weitergabe unter gleichen Bedingungen — Wenn Sie das lizenzierte Werk bzw. den lizenzierten Inhalt bearbeiten, abwandeln oder in anderer Weise erkennbar als Grundlage für eigenes Schaffen verwenden, dürfen Sie die 

daraufhin neu entstandenen Werke bzw. Inhalte nur unter Verwendung von Lizenzbedingungen weitergeben, die mit denen dieses Lizenzvertrages identisch, vergleichbar oder kompatibel sind. 

Wobei gilt: 

• Verzichtserklärung — Jede der vorgenannten Bedingungen kann aufgehoben werden, sofern Sie die ausdrückliche Einwilligung des Rechteinhabers dazu erhalten. 

• Sonstige Rechte — Die Lizenz hat keinerlei Einfluss auf die folgenden Rechte: 

• Die gesetzlichen Schranken des Urheberrechts und sonstigen Befugnisse zur privaten Nutzung; 

• Das Urheberpersönlichkeitsrecht des Rechteinhabers; 

• Rechte anderer Personen, entweder am Lizenzgegenstand selber oder bezüglich seiner Verwendung, zum Beispiel Persönlichkeitsrechte abgebildeter Personen. 

• Hinweis — Im Falle einer Verbreitung müssen Sie anderen alle Lizenzbedingungen mitteilen, die für dieses Werk gelten. Am einfachsten ist es, an entsprechender Stelle einen Link auf http:/ / creativecommons. org/ licenses/ 

by-sa/ 3. 0/ deed. de einzubinden. 

Haftungsbeschränkung 

Die „Commons Deed“ ist kein Lizenzvertrag. Sie ist lediglich ein Referenztext, der den zugrundeliegenden Lizenzvertrag übersichtlich und in allgemeinverständlicher Sprache aber auch stark vereinfacht wiedergibt. Die Deed selbst 

entfaltet keine juristische Wirkung und erscheint im eigentlichen Lizenzvertrag nicht. 

GNU Free Documentation License 

Version 1.2, November 2002 

Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. 

51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 

Everyone is permitted to copy and distribute verbatim copies 

of this license document, but changing it is not allowed. 

0. PREAMBLE 

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, 

either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. 

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free 

software. 

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this 

License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or 

reference. 

1. APPLICABILITY AND DEFINITIONS 

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free 

license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license 

if you copy, modify or distribute the work in a way requiring permission under copyright law. 

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. 

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) 

and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of 

historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. 

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above 

definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none. 

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a 

Back-Cover Text may be at most 25 words. 

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors 

or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to 

text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not 

Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque". 

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, 

PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, 

SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only. 

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title 

page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text. 

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section 

name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according 

to this definition. 

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards 

disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License. 

2. VERBATIM COPYING 

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced 

in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may 

accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. 

You may also lend copies, under the same conditions stated above, and you may publicly display copies. 

3. COPYING IN QUANTITY 

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that 

carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover 

must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document 

and satisfy these conditions, can be treated as verbatim copying in other respects. 

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. 

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a 

computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter 

option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time 

you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. 

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. 

4. MODIFICATIONS 

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role 

of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: 

• A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use 

the same title as a previous version if the original publisher of that version gives permission. 

• B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal 

authors, if it has fewer than five), unless they release you from this requirement. 

• C. State on the Title page the name of the publisher of the Modified Version, as the publisher. 

• D. Preserve all the copyright notices of the Document. 

• E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. 

• F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. 

• G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. 

• H. Include an unaltered copy of this License. 

• I. Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled 

"History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. 

• J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These 

may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. 

• K. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given 

therein. 

• L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. 

• M. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version. 

• N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section. 

• O. Preserve any Warranty Disclaimers. 

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as 

invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles. 

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization 

as the authoritative definition of a standard. 

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of 

Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are 

acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. 

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version. 

5. COMBINING DOCUMENTS 

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of 

the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers. 

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the 

title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of 

Invariant Sections in the license notice of the combined work.

Lizenz 199 

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled 

"Dedications". You must delete all sections Entitled "Endorsements". 

6. COLLECTIONS OF DOCUMENTS 

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, 

provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. 

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding 

verbatim copying of that document. 

7. AGGREGATION WITH INDEPENDENT WORKS 

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation 

is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not 

themselves derivative works of the Document. 

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the 

Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate. 

8. TRANSLATION 

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, 

but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any 

Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of 

this License or a notice or disclaimer, the original version will prevail. 

If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title. 

9. TERMINATION 

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate 

your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 

10. FUTURE REVISIONS OF THIS LICENSE 

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new 

problems or concerns. See http:/ / www. gnu. org/ copyleft/ . 

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and 

conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version 

ever published (not as a draft) by the Free Software Foundation. 

ADDENDUM: How to use this License for your documents 

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page: 

Copyright (c) YEAR YOUR NAME. 

Permission is granted to copy, distribute and/or modify this document 

under the terms of the GNU Free Documentation License, Version 1.2 

or any later version published by the Free Software Foundation; 

with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. 

A copy of the license is included in the section entitled 

"GNU Free Documentation License". 

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this: 

with the Invariant Sections being LIST THEIR TITLES, with the 

Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. 

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation. 

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free 

software.

Programmiersprache - Retroware.de

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?