Von A++ nach ARS++ E-Book

Georg P. Loczewski

• Herausgeber: tredition
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch
• Veröffentlichungsjahr: 2018

Seitenzahl: 339

Beschreibung

A++ ist eine Programmiersprache, die an Minimalismus nicht zu übertreffen ist. Ihr einziger Zweck ist es, an der Programmierung Interessierten zu helfen, so schnell und effizient wie nur möglich das Wesentliche der Programmierung zu erfassen. In verhältnismäßig kurzer Zeit werden Denkmuster eingeübt, die einen befähigen, sich müheloser in die großen populären Programmiersprachen einzuarbeiten, um in ihnen produktiv werden zu können. In diesem Buch wird eine Erweiterung von A++ vorgestellt, die einer neuen Programmiersprache entspricht (mit Compiler und virtueller Maschine) in der die Funktionalität von Scheme, Python, Java, C++ und C enthalten ist. Dies ist möglich, da in ARS++ eine Schnittstelle zu den anderen Sprachen namens ARSAPI eingebaut ist. Nicht nur ein A++-Interpreter wird zur Verfügung gestellt, sondern auch ein ARS++-Compiler und ein Interpreter für die virtuelle Maschine (AVIM). Auch dieses Buch enthält im Anhang eine Einführung in das Lambda-Kalkül von Alonzo Church. Das Buch wendet sich an alle Personen, die sich mit dem Erlernen der Kunst der Programmierung befassen. Dies sind vor allem Lehrende und Lernende an Hochschulen und den Oberstufen von Gymnasien in den Fachbereichen der Informatik, der Mathematik und der Physik.

Leseprobe

Von A++ nach ARS++

Georg P. Loczewski

Von A++ nach ARS++

A++ mit einer Schnittstelle zu anderen Programmiersprachen

Mit einer Einführung in das Lambda-Kalkül

IMPRESSUM

Copyright c 2018 Georg P. Loczewski

Von A++ nach ARS++

A++ mit einer Schnittstelle zu anderen Programmiersprachen

1. Auflage 2018 –Hamburg

Verlag & Druck: tredition GmbH

ISBN

978-3-7469-3643-7 (Paperback)

978-3-7469-3644-4 (Hardcover)

978-3-7469-3645-1 (e-Book)

Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollst ändig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung, noch irgendeine Haftung übernehmen.

Für Verbesserungsvorschl äge und etwaige Hinweise auf Fehler sind Verlag und Autor dankbar. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zul ässig.

Das Werk einschließlich all seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzul ässig und strafbar. Das gilt insbesondere für Verfielf ältigungen, Übersetzungen, Mikroverfilmungen und die Einspeisung, Verarbeitung und Verbreitung in elektronischen Systemen.

Meiner Frau Ursulaund meinen Söhnen Thomas und Johannes in Liebe gewidmet

Vorwort

Einleitung

Dieses Buch ist basiert auf dem 1032-seitigen Buch ‘Programmierung pur’, das in der 2. erweiterten Auflage von demselben Autor im Verlag S.Toeche-Mittler in Darmstadt im Jahre 2003 veröffentlicht wurde. Die 1. Auflage erschien im Jahre 2002. (Siehe [56].), [55]).

Die Eigenschaften von A++ werden in verschiedenen Büchern in dieser Reihe vorgestellt, jedesmal mit einem anderen Schwerpunkt. Das vorliegende Buch wird unter Punkt 4 in der folgenden Liste beschrieben.

1. In A++ Die kleinste Programmiersprache der Welt[58] geht es darum, die theoretischen Grundlage dieser Sprache zu präsentieren und die Mächtigkeit von A++ aufzuzeigen.

2. In dem 2. Buch Programmieren lernen mit A++[61] ist auch eine Einführung in A++ enthalten, der Fokus des Buches liegt aber darauf zu zeigen, wie in den anwendungsorientierten Programmiersprachen Python und Java A++-orientiert programmiert werden kann.

In der englischsprachigen Ausgabe A++ The Smallest Programming Language in the World wird außerdem die Programmiersprache Perl und die A++-orientierte Programmierung in dieser Sprache erläutert.Siehe: [59]!

3. In dem 3. Buch A++ und systemnahe Programmiersprachen[60] liegt der Schwerpunkt darauf, aufzuzeigen, wie auch in den Programmiersprachen C und C++ A++-orientiert programmiert werden kann.

4. In dem 4. Buch Von A++ nach ARS++[62] wird schließlich eine Erweiterung von A++ vorgestellt, die einer neuen Programmiersprache entspricht (mit Compiler und virtueller Maschine) in der die Funktionalität von Python, Java, C++ und C enthalten ist. Dies ist mglich, da in ARS++ eine Schnittstelle zu den anderen Sprachen namens ARSAPI eingebaut ist.

Die Werkzeuge und Hilfsmittel zu diesem Buch werden in einem Download-Verzeichnis im Internet bereitgestellt. Siehe: B.3 auf Seite 397.

Theoretische Grundlagen von A++

Das Wesentliche der Programmierung

Das Buch stellt auf einfache Weise die Grundlagen der Programmierung auf der Basis des Lambda-Kalküls vor. In dem Bemühen, Programmierung aus der Sicht des Lambda-Kalküls zu verstehen, geht es darum, das Wesentliche der Programmierung zu erfassen und uns davor zu bewahren, uns von einer Unzahl von Vorschriften und Regeln einer bestimmten Programmiersprache die Programmierung an sich vergraulen zu lassen. Es wird hier dank des Lambda-Kalküls eine Sicht der Programmierung gewonnen, die eine befreiende Wirkung hat. Das Denken wird aus den Niederungen des komplexen Regelwerks einer bestimmten Programmiersprache herausgeholt und heraufgehoben auf die Höhen eines einfacheren, umfassenderen und deshalb mächtigeren Denkens. Das Lambda-Kalkül bietet die theoretische Grundlage für eine solche Sicht.

ARS — Verallgemeinerung des Lambda-Kalküls

Die meisten Bücher, die die Thematik des Lambda-Kalküls aufgreifen, münden ein in die funktionale Programmierung und wenden sich ausschließlich den rein funktionalen Sprachen zu. Imperative oder objekt-orientierte Sprachen finden in solchen Büchern keine Berücksichtigung. In diesem Buch wird gezeigt, dass die drei Grundoperationen des Lambda-Kalküls, nämlich Abstraktion, Referenz und Synthese, so allgemein sind, dass sie in fast jeder Programmiersprache angewandt werden können. Diese Grundoperationen mögen zwar sehr trivial und abstrakt klingen, sie verändern jedoch die Denkweise und die Art zu programmieren sehr.

Erstaunlicherweise scheint die Programmierung als solche eine große Verwandtschaft mit der Kunst zu haben. In beiden menschlichen Aktivitäten wird die einen umgebende Wirklichkeit wahrgenommen und Abstraktionen dieser Wirklichkeit gebildet und in sich aufgenommen. Das Abstrahieren wird besonders deutlich in der urmenschlichen Aktivität der Namensvergabe. Mit der Bildung eines Namens wird eine Abstraktion vorgenommen. Der Name steht für die Wirklichkeit. Von allen Details dieser Wirklichkeit wird mit der Namensbildung abstrahiert. Die so gebildeten vielfältigen, ja unzähligen Abstraktionen werden vom Künstler wie vom Programmierer je nach Eigenart der Person gegebenenfalls neu zusammengesetzt. Es entsteht etwas Neues, mitunter etwas noch nie Dagewesenes. Diese Operation nennen wir Synthese oder auch Applikation. Die Bezugnahme auf die Abstraktionen der Wirklichkeit bezeichnen wir als Referenz.

Hiermit haben sich drei Grundoperationen herauskristallisiert, die das künstlerische Schaffen charakterisieren, so wie das der Programmierer.

Abstraktion: Etwas einen Namen geben.

Referenz: Auf etwas mit seinem Namen Bezug nehmen.

Synthese: Zwei oder mehrere Abstraktionen miteinander verknüpfen und dadurch eine neue Abstraktion bilden.

Was für ein Zufall, dass die ersten Buchstaben dieser drei Begriffe tatsächlich das Wort Kunst ergeben, nämlich in der lateinischen Sprache, einer der beiden Muttersprachen unseres abendländischen Kulturraumes: ARS! Die Kunst besteht nun darin, sinnvolle Abstraktionen zu bilden und ebenso sinnvolle Synthesen vorzunehmen.

Dass mit diesen drei Grundoperationen ein mathematisch-logisches System aufgebaut werden kann, hat der amerikanische Logiker Alonzo Church 1941 bereits in seinem Werk: The Calculi of Lambda Conversion bewiesen. Seine Theorie ist unter dem Namen Lambda Calculus oder auf deutsch Lambda-Kalkül bekannt geworden. Siehe auch hierzu [5].

Dass auf dieser Grundlage auch programmiert werden kann, ist in verschiedenen Büchern der Informatik ebenfalls bewiesen worden. Siehe hierzu [48],[47] und [13]. Wer mit der Kargheit dieser drei Grundoperationen gelernt hat umzugehen, sich sozusagen bewährt hat, der kann sich gestatten, ein paar weitere Primitivoperationen bzw. Syntax-Elemente hinzuzunehmen, um sich das Leben etwas zu versüßen. Dies haben Guy L. Steele und Gerald J. Sussman 1975 am MIT gemacht und so die Programmiersprache Scheme geschaffen.

Genau genommen stellt ARS eine Verallgemeinerung des Lambda-Kalküls dar. Die Verallgemeinerung besteht darin, dass der Begriff der Abstraktion allgemeiner als im Lambda-Kalkül definiert wird, nämlich als ’etwas einen Namen geben’. Hinter dem Namen verbergen sich alle Details des Definierten. Eine solche Namensvergabe setzt eine explizite Namensdefinition voraus.

Im Lambda-Kalkül dagegen ist eine explizite Vergabe eines Namens für eine Lambda-Abstraktion bei deren Bildung nicht vorgesehen. Dort erfolgt sie lediglich implizit bei einer Synthese von Lambda-Ausdrücken.

Die Auswirkungen dieses zunächst als klein erscheinenden Unterschiedes sind gewaltig: Während ein Ausbau des Lambda-Kalküls immer in die Funktionalen Programmiersprachen mündet, können mit ARS allgemeine Muster der Programmierung definiert werden, die sowohl auf die Funktionale Programmierung als auch auf die Objekt-orientierte und die Imperative Programmierung angewandt werden können.

Wer sich in seinem Programmieren von den in ARS formulierten Prinzipien leiten lässt, wird Programme erstellen, die nicht nur funktionieren, sondern die auch schön sind, Programme, bei denen der Leser mit Bewunderung die Abstraktionen und Synthesen nachempfinden und genießen kann.

A++ — die kleinste Programmiersprache der Welt([58])

Dass es möglich ist, ausgehend von den drei aufgezeigten Grundoperationen zu programmieren, und zwar ausschließlich auf ihnen aufbauend, wird im Teil 2 des Buches ausführlich aufgezeigt. Hier wird ARS als die kleinste Programmiersprache der Welt mit dem Namen A++ unter dem Gesichtspunkt der Sprache an sich und dem ihrer Anwendung vorgestellt. Der Name A++ ergibt sich ganz von selbst aus ARS: Abstraction + Reference + Synthesis.

A++ wird eingeführt als das universale Instrument zum Erlernen der Programmierung, das uns mit dem Wesentlichen der Programmierung konfrontiert und uns hilft diese Konfrontation zu meistern.

ARS++ — A++ im großen Stil

Nach intensiver Auseinandersetzung mit dem, was Programmierung im Wesentlichen ist, stellen wir uns den Problemen der Programmierpraxis. Um diese Konfrontation bestehen zu können müssen wir A++ ausbauen zu einem Instrument der Praxis, d.h. zu einer Programmiersprache, die den Anforderungen der Programmierpraxis genügt.

Diese neue Konfrontation führt uns zu ARS++, einer Programmiersprache, die auf ARS basiert, die Funktionalität der Programmiersprache Scheme einschließt und durch Zusätze Scheme übertrifft. Der Name ARS++ ist abgeleitet aus ARS +Scheme+Extensions.

Es sei noch kurz angesprochen, warum statt ARS++ nicht Scheme selbst als Programmiersprache in diesem Buch eingesetzt wurde. Scheme ist eine wunderbare Programmiersprache, aber leider sind in der Sprache selbst für die Programmierpraxis wichtige Randzonen nicht geregelt.

Die verschiedensten Scheme-Implementierungen versuchen nun auf ihre Weise Ergänzungen vorzunehmen, wie wir das ja auch in ARS++ getan haben. Leider scheint es jedoch keine Scheme-Implementierung zu geben, die all die Bereiche abdeckt, die wir in den Fallstudien benötigen und die außerdem noch auf allen Plattformen zur Verfügung steht und schließlich auch noch freie Software ist.

So waren wir gezwungen ARS++ zu kreieren mit den zusätzlichen Vorteilen der vollen ARS-Kompatibilität, der Offenheit und Nachvollziehbarkeit der Implementierung und der sich daraus ergebenden Ergänzungsmöglichkeit nach einem bereits vorgegebenen Muster.

ARS und die anderen Sprachen

Ein weiteres Hauptthema von ‘A++ in Theorie und Praxis’ ist die Auswirkung der sich in ARS manifestierenden Denkweise auf den Umgang mit den großen wohl etablierten Programmiersprachen.

Es wird Wert darauf gelegt aufzuzeigen, dass selbst das Lernen von neuen Programmiersprachen nach einer Intensivschulung in A++ um ein Vielfaches erleichtert wird und schneller zu Produktivität in der neuen Sprache führt.

Für diese neue Konfrontation wurde in diesem Buch die Programmiersprache Java ausgewählt. In dem Buch ‘Programmierung pur’[56] (ISBN 3-87820-108-7), das vom selben Autor im Jahre 2003 im S.Toeche-Mittler Verlag veröffentlicht wurde, werden ebenso folgende Programmiersprachen berücksichtigt: C, C++, Python und Perl.

Für die Auswahl der Sprachen in den beiden Büchern waren folgende Überlegungen entscheidend:

1.Java ist die populärste Programmiersprache.

2.Python ist eine relativ junge Sprache, die sich auszeichnet durch ein hohes Maß an Einfachheit, Mächtigkeit, Flexibilität und Dynamik. Außerdem gibt es für Python Anwendungsbeispiele aus fast allen Gebieten und eine überaus reichhaltige Bibliothek von Funktionen und Klassen. All dies ist im Quellcode verfügbar.

3.Perl Es hat sich gezeigt, dass es sinnvoll ist die Programmiersprache Perl ebenfalls in diesem Buch zu berücksichtigen, da sie nicht nur eine von Systemadministratoren sehr geschätzte Skriptspache ist und als Internetsprache ebenso weite Verbreitung gefunden hat, sondern auch deswegen, weil in ihr die wesentlichen Gedanken dieses Buches direkt umgesetzt werden können. Man kann sagen, dass ’Perl’ eine Lambda-Sprache ist.

4.C++ ist die Programmiersprache, die heutzutage meistens gewählt wird, wenn es darum geht, große Anwendungspakete zu erstellen, bei denen Effizienz eine hohe Priorität besitzt.

5.C ist die Sprache, aus der C++ entstanden ist, der Sprache Nr. 1, wenn es darum geht, systemnahe Software, wie Betriebssysteme (z.B. Linux-Kernel, Compiler etc) zu programmieren, oder wenn Effizienz der Anwendung unverzichtbar an erster Stelle steht.

Die Programmiersprache C ist nun mal die Sprache mit der größten Maschinennähe und damit die Sprache, in der die Computer-Ressourcen am besten genutzt werden können. Das was ihr fehlt ist die Nähe zu den zu programmierenden Anwendungen. Diese Verbindung schafft ARSAPI.

In ARS geht es nur um die Lösung der Probleme. In ARS wird abstrahiert von dem Computer und der Syntax irgendeiner Sprache. ARSAPI schlägt die Brücke zwischen beiden extremen Polen. Mit Hilfe von ARSAPI ist es möglich auf einfache Weise in C objekt-orientiert und funktional zu programmieren ohne viel von der Effizienz der Sprache aufzugeben.

Adressatenkreis

Primäre Zielgruppe

Das Buch wendet sich an Programmierer und solche, die es werden wollen. Es möchte ihnen mit der speziellen Denkweise die Programmierung erleichtern, besonders auch das Erlernen neuer Sprachen. Mit der nahe gelegten Sicht der Programmierung wird eine Sprachenunabhängigkeit gewonnen, ja man ist sogar offen für verschiedene Paradigmen der Programmierung. Mit der Erfahrung der gewonnenen Flexibilität ausgerüstet wird ein Programmierer oder eine Programmiererin mit mehr Freude und größerer Effizienz die Probleme der Programmierung meistern.

Das Buch wendet sich auch an Anfänger der Programmierung. Jedoch sollte ein großes Interesse für die Programmierung aufgrund einer persönlichen Eignung und Neigung vorhanden sein.

Zusammenfassend ist die primäre Zielgruppe des Buches wie folgt zu beschreiben:

Das Buch ist gedacht für Menschen, die einen Ausbildungsbedarf in den Grundlagen der Programmierung besitzen.

• Dies sind Studenten aller Fachrichtungen der Informatik sowie Studenten der Mathematik und Physik.

• Dies sind ferner alle Angestellten in der Industrie, die sich, aus welchen Gründen auch immer, mit der Programmierung auseinandersetzen müssen.

•Programmierer, die bereits programmieren können, sich aber nicht scheuen, etwas Neues kennen zu lernen, kommen als potentielle Nutznießer von ‘A++ im großen Stil’ gewiss ebenfalls in Betracht.

Sekundäre Adressaten

• In Fachkreisen gilt das Lehrbuch der Informatik vom Massachusetts Institute of Technology (MIT), das legendäre SICP-Buch, als eines der besten Lehrbücher der Informatik. An den deutschen Hochschulen wird dieses Buch zwar empfohlen, aber die Vorlesungen orientieren sich meistens nicht an ihm, sodass viele Studenten entmutigt werden, sich mit dem Buch auseinander zu setzen.

Hier könnte ‘A++ in Theorie und Praxis’ eine Lücke füllen. Es ist einfacher, grundlegender und nicht so komplex wie das SICP-Buch, geht aber in dieselbe Richtung, nämlich vom Lambda-Kalkül her die Programmierung aufzubauen. Dazu kommt der größere Bezug zur Praxis durch die gleichzeitige Anwendung der Grundlagen auf fünf Programmiersprachen und die vier großen Fallstudien.

Fallstudien

1. Die erste Fallstudie ist ein A++ – Interpreter. Dies ist ein Programm, das A++ – Programmcode auswertet. Diese Fallstudie ist in diesem Buch in ARS++ implementiert1wird auch die Implementierung in Perl, Python, Java, C++ und C vorgestellt. Der ARS-Interpreter soll nicht nur dazu dienen, die A++ – Beispiele nachvollziehen zu können, sondern ist gleichzeitig eine Anwendung der ARS-gemäßen Programmierung in der jeweiligen Zielsprache.

2. Die zweite Fallstudie ist in Java implementiert und besteht aus einem Applet (”OntoSimula“), das das Leben mehrerer Philosophen simuliert. Die Fallstudie enthält ein eigenes dynamisches Objektsystem, das die Möglichkeiten des statischen Standard-Objektsystems von Java (das allerdings mitbenutzt wird), weit übersteigt. Diese Dynamik im Objektsystem ist gefordert, wenn es darum geht, ein lebendiges System zu simulieren, in dem es Wachstum, Veränderung, Altern und Ähnliches gibt.

Nutzen des Buches

Auf die Frage: „Was bringt es dem Leser oder der Leserin dieses Buch zu lesen; welchen Nutzen kann man aus ihm ziehen?“, können folgende Punkte eine Antwort geben:.

• Das Lesen von ‘A++ in Theorie und Praxis’ schafft eine Vertrautheit mit den drei Paradigmen der Programmierung, nämlich mit der funktionalen Programmierung, der objektorientierten Programmierung und der imperativen Programmierung. Leser können später selbst entscheiden, welcher Programmierstil im konkreten Fall zu bevorzugen ist. Konkreter Fall ist hier nicht identisch mit irgendeinem Projekt, denn selbst innerhalb eines Programmes kann ‘hier’ der eine Stil und ‘dort’ ein anderer Stil zu empfehlen sein.

• Da die in ‘A++ in Theorie und Praxis’ vermittelten Grundlagen der Programmierung sehr allgemein gehalten sind, kann man sie in den meisten Programmiersprachen anwenden. Das bedeutet, dass Leserinnen und Leser neue Programmiersprachen leichter erlernen werden, weil sie die in ‘A++ in Theorie und Praxis’ aufgezeigten Muster der Programmierung in den neuen Sprachen lediglich zum Ausdruck bringen müssen.

Diese Muster der Programmierung sind sehr einfach, aber dennoch umfassend und mächtig. Mit ihnen können die meisten Programmieraufgaben gelöst werden.

• In ‘A++ in Theorie und Praxis’ lernt man nebenbei, sich ein eigenes Objektsystem aufzubauen. Diese Technik kann sehr hilfreich sein beim Umgang mit Programmiersprachen, die nicht objekt-orientiert sind.

>Dieses Objektsystem ist außerdem noch ein dynamisches Objektsystem. Angewandt auf die Programmiersprache Java bedeutet dies eine Erweiterung und Bereicherung des Standard-Objektsystems.

Besonderer Wert des Buches

Die solide Grundlage des Lambda-Kalküls wird in ein Grundlagenstudium der Programmierung integriert,

•ohne, dass eine Fixierung auf spezielle funktionale Programmiersprachen erfolgt

• und ohne, dass dieser Versuch in eine Mathematisierung der Programmierung mündet.

In anderen Büchern wird funktionale Programmierung meistens nur im Zusammenhang mit einer ganz speziellen komplexen Programmiersprache, wie z.B. Haskell eingeführt und das Lambda-Kalkül wird, wenn es überhaupt als theoretische Grundlage für die funktionale Programmierung erwähnt wird, immer als logisch-mathematisches System gesehen und entsprechend in mathematischer Notation präsentiert. Es steht auf einem hohen mathematischen Podest, das immer noch für viele Programmierer abschreckend wirkt.

In ’A++ in Theorie und Praxis ’ dagegen werden die Grundoperationen des Lambda-Kalküls, Abstraktion, Referenz und Synthese als einfache grundlegende Programmiersprache mit Programmbeispielen und einem eigenen ARS-Interpreter vorgestellt.

Es ist somit die besondere Leistung dieses Buches, Programmierern und Programmiererinnen den Schrecken vor dem Lambda-Kalkül zu nehmen und letzteres nutzbar zu machen für den Prozess des Erlernens der Kunst des Programmierens.

Die Zielgruppe für dieses Kapitel und das ganze Buch ist somit nicht eine kleine elitäre Gruppe von Wissenschaftlern, sondern alle Studenten und Studentinnen der Informatik, weil es hier um die Grundlagen der Programmierung geht, auf einem Niveau von Programmierern und nicht von Mathematikern.

Danksagung

Dieses Buch wurde auf dem PC erstellt mithilfe qualitativ erstrangiger Software-Tools, die vongroßen Idealistender Weltfreizur Verfügung gestellt wurden. Die primären Werkzeuge2 sind:

1. Das 1982 von Donald E. Knuth veröffentlichte Textsatzsystem TEX und das 1984 von Leslie Lamport dazu entwickelte Makropaket LATEX.

2. Die von Thomas Esser (Universität Hannover) für Linux erstellte Implementierung des Tex/Latex-Systems teTeX.

3. Das von Linus Thorvalds (Universität Helsinki) 1991 geschaffene PC-Betriebssystem Linux

4. Das X Window System für Linux XFree86 mit den vielfältigen Window-Managern und Desktop-Environments (z.B. fvwm SuSE-Desktop, kde, gnome).

5. Die programmierbaren Texteditoren elvis und vim, die von Steve Kirkendall bzw. von Bram Moolenaar entwickelt wurden.

6. Die von Brian Fox (Free Software Foundation) und von Chet Ramey (Case Western Reserve University) erstellte bash (Bourne Again Shell).

7. Das von Tomas Rokicki (Stanford University) erstellte Konvertierungsprogramm dvips zum Erstellen eines Postscript-Dokumentes aus den von TEX gelieferten dvi-Dokumenten und die von Angus J.C. Duggan zum Manipulieren von Postscript-Dokumenten (Skalieren der Seiten, Anordnung der Seiten in Faszikeln, etc.) erstellten Werkzeuge psutils.

8. Das von Timothy O. Theisen (University of Wisconsin-Madison) erstellte Programm ghostview zum Visualisieren und Drucken von Postscript-Dokumenten.

9. Das von Carsten Heinz erstellte LATEX-Makro-Paket listings.dtx zum Formatieren von Programmlisten für die meisten Programmiersprachen.

10. Das von Nikos Drakos (University of Leeds) ursprünglich erstellte und von Ross Moore (Macquerie University, Sydney) sowie Marek Rouchal (Infineon Technologies AG, München) weiterentwickelte Programm latex2html LATEX-Dokumente in HTML übersetzt werden können.

Mein besonderer Dank gilt denjenigen, die Scheme geschaffen haben, nämlich Guy L. Steele und Gerald J. Sussman, sowie den vielen Autoren, die so ausgezeichnete Bücher über Scheme und andere Programmiersprachen geschrieben haben, wie Jacques Chazarain, mit seinem Buch Programmer Avec Scheme, das ich für mich persönlich als eines der besten Lehrbücher der Informatik halte, sowie Peter Norvig und Samuel N. Kamin. (Siehe hierzu [13], [70] und [48]).

Alonzo Church, dem wir das Lambda-Kalkül verdanken, sei ganz besonderer Dank, obwohl er selbst natürlich nichts davon ahnte, dass er einen so großen Beitrag zur Informatik leistete, dass er für die Theorie der Programmiersprachen eine Grundlage geschaffen hatte. Der Dank erstreckt sich selbstverständlich auch auf alle anderen Autoren, die in dem bibliographischen Anhang aufgeführt sind.

Auch Brent Benson gebhrt mein Dank, der es mir ermöglicht hat mit Hilfe seiner Bibliothek ‘libscheme’ die Programmiersprache ARS++ zu schaffen, die aus A++ mit Hilfe der vorgegebenen, aus libscheme importierten Primitivoperationen, eine Programmiersprache der Praxis macht, angereichert durch über Scheme und ‘libscheme’ hinausgehende Erweiterungen, um so den praktischen Anforderungen der Fallstudien voll gerecht werden zu können.

Ähnlichen Dank schulde ich Hans J. Boehm, der mit seinem ‘black-box’ Garbage-Collector für C und C++ Programme, die Komplexität der Fallstudien für dieses Buch auf ein vertretbares Maß herunterschrauben half.

Was wäre schließlich die Welt ohne Richard Stallman, dem wir Programmierer nicht nur den Emacs sondern auch den GNU-C-Compiler verdanken und all den Reichtum, den die von ihm gegründete Free Software Foundation der Welt anzubieten hat! Auch dieses Buch hätte ohne ihn und die vielen Programmierer, die ihre Software als freie Software veröffentlichen, nicht realisiert werden können!

Möge dieses Buch Programmierern das Faszinierende von ARS entdecken helfen und sie zu einem souveränen Umgang mit den Elementarteilchen der Programmierung führen und sie dadurch befähigen, mit größerer Freude und Produktivität die Herausforderungen der Programmierung zu meistern.

Georg P. Loczewski

Groß-Zimmern, im Mai 2018

Inhaltsverzeichnis

Vorwort

I Allgemeine Grundlagen

1Grundlegende Begriffe

1.1 Programmierung

1.2 Abstraktion

1.3 Referenz

1.4 Synthese oder Applikation

2 Wichtige Abstraktionsmechanismen

2.1 Bildung von Funktionen

2.2 Bildung von Modulen und Klassen

2.3 Bildung von Paketen in Java

3 Operationen in Funktionen

3.1 Allgemeine Grundfunktionen

3.1.1 Abstraktion

3.1.2 Referenz

3.1.3 Synthese oder Applikation

3.2 Definition von Variablen

3.3 Definition von Funktionen

3.4 Erzeugung von Objekten

3.5 Zuweisung von Werten

3.6 Testen von Werten

3.7 Wiederholung von Operationen

3.8 Ein-/Ausgabeoperationen

3.9 Arithmetische Operationen

3.10 Relationale Operationen

3.11 Boolesche Operationen

3.12 Bibliotheksfunktionen

4 Grundlegende Datentypen

4.1 Atom

4.2 Listen

4.3 Verarbeitung von Listen

4.4 Dictionaries

5 Programmiersprachen

5.1 Allgemeine Programmiersprachen

5.2 Spezielle Programmiersprachen

II Die Programmiersprache A++

1 Einführung

1.1 A++ – Die kleinste Programmiersprache der Welt

1.1.1 Wesen und Zweck von A++

1.1.2 Weitere Eigenschaften von A++

1.2 Ursprung von A++

1.2.1 Verallgemeinerung des Lambda-Kalküls

1.3 Konstitutive Prinzipien in A++

1.3.1 Abstraktion

1.3.2 Referenz

1.3.3 Synthese

1.3.4 Closure

1.3.5 Lexical Scope

2 Sprachdefinition

2.1 Syntax und Semantik von A++

2.2 Beispiele zur Syntax von A++

2.2.1 Beispiele zur Abstraktion 1. Alternative in 2.2

2.2.2 Beispiele zur Abstraktion 2. Alternative in 2.2

2.2.3 Beispiele zur Referenz 2.3

2.2.4 Beispiele zur Synthese 2.4

2.3 A++ Erweiterung

2.3.1 Syntax von A++ mit vorgegebenen Primitiv-Abstraktionen

2.3.2 Beispiele zu den Erweiterungen in A++

3 Erste Entfaltung von A++

3.1 Programmierstil in A++

3.2 Grundlegende Logische Abstraktionen

3.2.1 Abstraktionen ‘true’ und ‘false’

3.2.2 Abstraktionen ‘lif’

3.3 Erweiterte Logische Abstraktionen

3.4 Numerische Abstraktionen

3.4.1 Abstraktion für die Zahl ‘0’

3.4.2 Abstraktion für die Zahl ‘1’

3.4.3 Abstraktion für die Zahl ‘2’

3.4.4 Abstraktion für das Prädikat ‘zerop’

3.4.5 Abstraktion für die Zahl ‘3’

3.4.6 Utility-Abstraktion ‘compose’

3.4.7 Abstraktion für die Addition

3.4.8 Abstraktion für die Inkrementierung

3.4.9 Abstraktion für die Multiplikation

3.5 Abstraktionen für allgemeine Listen

3.5.1 Abstraktion für den Konstruktor

3.5.2 Abstraktion für den Selektor ‘lcar’

3.5.3 Abstraktion für den Selektor ‘lcdr’

3.5.4 Anwendung der grundlegenden Operationen für Listen

3.5.5 Abstraktion für das Ende einer Liste

3.5.6 Abstraktion für das Prädikat ‘nullp’

3.5.7 Abstraktion für die Längenabfrage

3.5.8 Abstraktion zum Entfernen eines Objektes aus einer Liste

3.6 Erweiterte Arithmetische Abstraktionen

3.6.1 Abstraktion für ‘zeropair’

3.6.2 Abstraktion für die Dekrementierung

3.6.3 Abstraktion für die Subtraktion

3.7 Relationale Abstraktionen

3.7.1 Abstraktion für das Prädikat ‘gleich’

3.7.2 Abstraktion für das Prädikat ‘größer als’

3.7.3 Abstraktion für das Prädikat ‘kleiner als’

3.7.4 Abstraktion für das Prädikat ‘größer gleich’

3.8 Rekursion

3.8.1 Abstraktion für die Berechnung der Fakultät

3.8.2 Abstraktion für die Summation

3.9 Funktionen Höherer Ordnung

3.9.1 Abstraktion ‘compose’

3.9.2 Abstraktion für die ‘curry’-Funktion

3.9.3 Abstraktion für die Abbildung einer Liste

3.9.4 Abstraktion für die ‘curry map’-Funktion

3.9.5 Abstraktion für die Auswahl aus einer Liste

3.9.6 Abstraktion für die Suche nach einem Objekt in einer Liste

3.9.7 Abstraktion für den Zugriff auf ein Element einer Liste

3.9.8 Abstraktion für die Iteration über die Elemente einer Liste

3.10 Mengen-Operationen

3.10.1 Abstraktion für das Prädikat ‘memberp’

3.10.2 Abstraktion für das Hinzufügen eines Elementes

3.10.3 Abstraktion für die Vereinigung von Mengen

4 Erste Anwendung von A++

4.1 Sortierung

4.1.1 Abstraktion für das sortierte Einfügen in eine Liste

4.1.2 Abstraktion für die Sortierung

4.2 Assoziative Listen in A++

4.2.1 Abstraktionen für assoziative Listen

4.2.2 Anwendung der Abstraktionen für assoziative Listen

5 Imperative Programmierung in A++

5.1 Ausführung von Anweisungen

5.2 Auswertung von Ausdrücken

5.3 Programmierstile in A++

5.4 Beispiele für imperative Programmierung

5.4.1 Beispiele für OOP sind auch Beispiele für imperative Programmierung

5.4.2 Besonderes Beispiel für imperative Programmierung

6Objekt-Orientierte Anwendung von A++

6.1 Einleitung

6.1.1 Bildung von Klassen

6.1.2 Instanzen von Klassen

6.1.3 Beispiele für Objekt-orientierung in A++

6.2 Erstes Beispiel zur Objektorientierung in A++

6.2.1 Konstruktor für Objekte der Klasse “account”

6.2.2 Erzeugung des Objektes “acc1” durch Aufruf von “make-account”

6.2.3 Senden der Botschaft “deposit” an das Objekt “acc1”

6.2.4 Ausführen der Funktion “deposit”

6.2.5 Detaillierter Code in A++

6.2.6 Anmerkungen zu dem ersten Beispiel zur Objektorientierung

6.2.7 Anmerkungen zum Aufruf der Funktion ‘konto’

6.3 Zweites Beispiel zur Objektorientierung in A++

6.3.1 Anmerkung zu den einzelnen Klassen

6.3.2 Beziehungen zwischen den Klassen

6.3.3 Zusammenfassung

6.4 Drittes Beispiel zur Objektorientierung in A++

6.4.1 Anmerkung zu den einzelnen Klassen

7 Abstraktion, Referenz und Synthese im Detail

7.1 Addition der zwei Zahlen ‘two’ und ‘three’

7.1.1 Synthese von ‘add’ und ‘two three’ (1)

7.1.2 Abstraktion von ‘add’ (1)

7.1.3 Auflösung der Referenz von ‘add’ in [1]

7.1.4 Synthese von (lambda(m n)...) und ‘two three’ in [3]

7.1.5 Abstraktion von ‘compose’

7.1.6 Auflösung der Referenz von ‘compose’ in [4]

7.1.7 Synthese von (lambda(f g)...) und ‘(two f) (three f)’ in [6]

7.1.8 Abstraktion von three:

7.1.9 Auflösung der Referenz von ‘three’ in [7]

7.1.10 Synthese von (lambda(f)...) und ‘f’ in [9]

7.1.11 Synthese von (lambda(x)...) und ‘x’ in [10]

7.1.12 Abstraktion von two:

7.1.13 Auflösung der Referenz von ‘two’ in [11]

7.1.14 Synthese von (lambda(f)...) und ‘f’ in [13]

7.1.15 Synthese vom inneren (lambda(x) .) und ‘(f (f (f x)))’ in [14]

7.2 Multiplikation der zwei Zahlen ‘two’ und ‘three’

7.2.1 Synthese von mult und ‘two three’

7.2.2 Abstraktion von mult:

7.2.3 Auflösung der Referenz von ‘mult’ in [17]

7.2.4 Synthese von (lambda(m n) ... ) und ‘two three’ in [19]

7.2.5 Abstraktion von compose:

7.2.6 Auflösung der Referenz von ‘compose’ in [20]

7.2.7 Synthese von (lambda(f g)...) und ‘two three’ in [22]

7.2.8 Abstraktion von two:

7.2.9 Abstraktion von three:

7.2.10 Auflösung der Referenz von ‘two’ und ‘three’ in [23]

7.2.11 Synthese vom inneren (lambda(f) .) und ‘x’ in [26]

7.2.12 Synthese von (lambda(f)...) und ‘(lambda(x0) .)’ in [28]

7.2.13 Synthese vom inneren (lambda(x0) .) und ‘x1’

7.2.14 Synthese von (lambda(x0)...) und ‘(x(x(x x1)))’

7.2.15 Umbenennung der Variablen: x –> f und x1 –> x

8 Infrastruktur für A++

8.1 Support-Funktionen

8.1.1 Abstraktion für die Ausgabe einer Zahl

8.1.2 Abstraktion für die Ausgabe eines booleschen Wertes

8.1.3 Abstraktion für die Ausgabe von Listen

8.2 A++ Interpreter

8.2.1 Linux

8.2.2 MS-Windows

8.2.3 Basis-Abstraktionen

8.2.4 Programmbeendigung

8.3 Initialisierungsdatei für den ARS-Interpreter

III Von A++ nach ARS++

1 ARS++ – Erste Ausbaustufe

1.1 Die Programmiersprache ARS++

1.1.1 Wesen und Zweck von ARS++

1.1.2 ARS++ und Scheme

1.1.3 Unterschied zwischen ARS++ und Scheme

1.1.4 Ausbau von A++ in ARS++

1.2 Struktur von ARS++ in der ersten Ausbaustufe

1.2.1 EBNF-Notation

1.2.2 Special-Forms in ARS++

1.2.3 Makros in ARS++

1.2.4 Auswertung der Argumente von Funktionen

1.2.5 Anmerkung zur Bedeutung der Klammern

1.3 Wichtige Abstraktionsmechanismen

1.3.1 Etwas einen Namen geben

1.3.2 Bildung von Funktionen

1.3.3 Bildung von Klassen

1.3.4 Bildung von Makros

1.4 Operationen in Funktionen

1.4.1 Abstraktion

1.4.2 Referenz

1.4.3 Synthese

1.4.4 Definition von Variablen

1.4.5 Erzeugung von Objekten

1.4.6 Zuweisung von Werten

1.4.7 Testen von Werten

1.4.8 Wiederholung von Operationen

1.4.9 Ein-/Ausgabeoperationen

1.4.10 Arithmetische Operationen

1.4.11 Relationale Operationen

1.4.12 Boolesche Operationen

1.4.13 Bibliotheksfunktionen

1.5 Grundlegende Datentypen

1.5.1 Atom

1.5.2 Listen

1.5.3 Verarbeitung von Listen

1.5.4 Dictionaries

1.5.5 Assoziative Listen

1.5.6 Vektoren

1.6 Besonderheiten

1.6.1 Sequentielle Programmierung

1.6.2 “Continuations”

1.6.3 “Delayed Evaluation”

2 ARS++ – Zweite Ausbaustufe

2.1 Überblick

2.2 Struktur von ARS++ in der zweiten Ausbaustufe

IV Anwendung von ARS++

1 Anwendung der Werkzeuge

1.1 Anwendung des Compilers ACOMP

1.1.1 Anwendung von ‘arscomp.scm’

1.1.2 Anwendung von ‘acomp.avm’

1.2 Anwendung des Interpreters AVIM im Normalmodus

1.3 Anwendung des Interpreters AVIM im Debugmodus

1.4 Anwendung von AVIM mit internem Garbage Collector

1.4.1 Aufruf von AVIM 1.0i

2 Einfaches Beispiel: Bibliotheksverwaltung

2.1 Einleitung und Überblick

2.2 Anmerkung zu den einzelnen Klassen

2.2.1 Klasse: ‘base-object-class’

2.2.2 Klasse: ‘library’

2.2.3 Klasse: ‘book’

2.2.4 Klasse: ‘person’

2.2.5 Klasse: ‘author’

2.2.6 Klasse: ‘reader’

3 ‘Full Continuations’ im Einsatz

3.1 Mit Backtracking Probleme lösen

3.1.1 Backtracking-Funktionen

3.1.2 Das Problem der acht Königinnen

3.2 Multi-Tasking ‘home made’

3.2.1 Einführung

3.2.2 Dispatcher für ‘non-preemptive Multi-Tasking’

4 ARS++ - Anwendung: ARS-Interpreter

4.1 Einführung zu dem A++ - Interpreter in ARS++

4.2 Syntax von ARS

4.3 Beschreibung der Funktionen

4.3.1 Hauptfunktionen

4.3.2 ars-eval

4.3.3 ars-apply

4.3.4 get-referenced-value

4.3.5 binding-in-env

4.3.6 tagged-by?

4.3.7 add-modify-variable!

4.3.8 make-closure

4.3.9 force-eval!

4.3.10 list-of-real-values

4.3.11 list-of-args

4.3.12 eval-body-of-closure

4.3.13 add-frame-to-environment

4.3.14 make-environment-frame

4.3.15 print-object

4.3.16 driver

4.3.17 primitive-abstractions

4.3.18 build-global-environment

4.3.19 print-frame

4.3.20 print-env

4.3.21 print-composed

4.3.22 display-all

4.3.23 display-alln

4.3.24 the-global-environment

4.4 Quell-Code des A++ - Interpreters

4.5 Test-Suite für den A++ - Interpreters

V ARSAPI

1 Einleitung

1.1 Das Akronym ARSAPI

1.2 Das Bild der Muschel

1.3 Anwendung von ARSAPI in der Praxis

2 ARS (A++)

2.1 Syntax und Semantik von ARS

2.2 Grundlegende Logische Abstraktionen in ARS

2.3 Erweiterte Logische Abstraktionen in ARS

2.4 Numerische Abstraktionen in ARS

2.5 Grundlegende Abstraktionen für Listen (1) in ARS

2.6 Grundlegende Abstraktionen für Listen (2) in ARS

2.7 Erweiterte Arithmetische Abstraktionen in ARS

2.8 Relationale Abstraktionen in ARS

2.9 Erweiterte Abstraktionen für Listen in ARS

2.10 Funktionen Höherer Ordnung

2.11 Mengen-Operationen

2.12 Imperative Programmierung in ARS

2.13 Support-Funktionen für ARS

2.14 Objekt-Orientierte Programmierung in ARS

3 ARSAPI für Java

3.1 Datentypen-Überblick

3.2 Umgebung einer Lambda-Abstraktion

3.2.1 Klasse ‘LEnv’

3.2.2 Klasse ‘NList’

3.2.3 Klasse ‘VList’

3.3 Klasse LClosure

3.4 Allgemeine Listen: Klasse LList

4 ARSAPI für C

4.1 Datentyp ‘NAME’

4.2 name table

4.3 Abstrakter Datentyp ‘VALUE’

4.4 Datentyp ‘INTV’

4.5 Datentyp ‘SYMV’

4.6 Datentyp ‘STRV’

4.7 Datentyp ‘PAIRV’

4.8 Datentyp ‘NLIST’

4.9 Datentyp ‘VLIST’

4.10 Datentyp ‘ENV’

4.11 Datentyp ‘CLAM’

4.12 Beispiel ‘trivy’ für C

4.13 Anwendungsbeispiel

5 ARSAPI für C++

5.1 Datentypen-Überblick

5.2 Allgemeine Typendefinitionen

5.3 Umgebung einer Lambda-Abstraktion

5.3.1 Klasse ‘Env’

5.3.2 Klasse ‘NList’

5.3.3 Klasse ‘VList’

5.4 Klasse Clam

5.5 Allgemeine Listen: Klasse List

5.6 Klasse Integer

5.7 Klasse String

5.8 Klasse Symbol

5.9 Globale Funktionen

5.10 Beispiel ‘trivy’ für C++

5.11 Anwendungsbeispiel

VI ARS++ - Implementierung

1 Virtuelle Maschine von ARS++: AVIM

1.1 Überblick

1.1.1 Allgemeine Beschreibung

1.1.2 Eigenschaften der ARS++ - Implementierung

1.1.3 Hauptkomponenten von ARS++

1.2 Aufbau von AVIM

1.2.1 S-Register

1.2.2 E-Register

1.2.3 C-Register

1.2.4 D-Register

1.2.5 IS-Register

1.2.6 G-Register

1.3 Befehle der virtuellen Maschine ‘AVIM’

1.3.1 Befehlsrepertoire: Überblick

1.3.2 Befehlsrepertoire: Detailbeschreibung

1.3.3 Basisstrukturen in der AVIM-Programmierung

1.4 Kleine Anwendungsbeispiele

1.4.1 Einfache Addition

1.4.2 Addition und Multiplikation

1.4.3 IF-THEN-ELSE-Struktur

1.4.4 Deklaration von Variablen

1.4.5 Definition von Lambda-Abstraktionen

1.4.6 Synthese von zwei Lambda-Ausdrücken

1.4.7 Rekursive Berechnung der Fakultät

1.4.8 Berechnung der Fakultät mit ‘tail recursion’

2 Implementierung von ARS++ als Prototyp in Scheme

2.1 Besondere Eigenschaften der Implementierung von ARS++

2.1.1 ‘tail recursion’

2.1.2 ‘full continuations’

2.1.3 ‘define’-Anweisung

2.1.4 Makros

2.2 Einführung zum Prototypen von AVIM

2.2.1 Besonderheiten des Prototyps

2.3 Anwendung der ARS++ - Prototypen

2.3.1 Laden der ARS++ - Prototypen

2.3.2 Benutzung des Compilers

2.3.3 Ausführung des Programm-Codes in der virtuellen Maschine

2.3.4 Integrierter Aufruf des Compilers/Interpreters

2.4 Quellcode des Prototypen für die virtuelle Maschine

3 Erweiterung von ARSAPI für C

3.1 Überblick

3.1.1 Integration von Primitivfunktionen

3.1.2 Ausbau des Datentyps ‘STRV’

3.1.3 Verzicht auf den Datentyp ‘VLIST’

3.1.4 Einführung des Datentyps ‘LAMBV’

3.1.5 Einführung des Datentyps ‘VECV’

3.1.6 Integration einer Ein-/Ausgabe-Bibliothek

3.1.7 Integration einer Datenbankschnittstelle

3.1.8 Integration einer TCP/IP-Schnittstelle

3.1.9 Integration einer Schnittstelle für Reguläre Ausdrücke

3.1.10 Erweiterung der Verwaltung der Namensräume

3.1.11 Datentypen in ARSAPI für C

3.2 Datentyp ‘NAME’

3.3 Abstrakter Datentyp ‘VALUE’

3.4 Datentyp ‘GVAR’

3.5 Datentypen ‘INTV/DBLV’

3.6 Datentyp ‘SYMV’

3.7 Datentyp ‘STRV’

3.8 Datentyp ‘PAIRV’

3.9 Datentyp ‘VECV’

3.10 Datentyp ‘ENVV’

3.11 Datentyp ‘CLAM’

3.12 Datentyp ‘LFUN’

3.13 Datentyp ‘LAMB’

3.14 Datentyp ‘PRIM’

3.15 Datentyp ‘CFUN’

3.16 Datentyp ‘INPV’

3.17 Datentyp ‘OTPV’

3.18 Datentyp ‘HT’

3.19 Datentyp ‘DBMV’

3.20 Datentyp ‘datum’

3.21 Datentyp ‘TCPV’

3.22 Datentyp ‘REGXV’

4 Implementierung von AVIM in C

4.1 Auszug aus der Definitionsdatei

4.2 Quellcode der Virtuellen Maschine

4.3 Quellcode für das Namens-Management

4.4 Quellcode für das Umgebungs-Management

4.5 Quellcode für das Funktions-Management

4.6 Testen von AVIM

5 AVIM mit internem Speichermanagement

5.1 Einführung

5.2 Grundlegendes Verfahren

5.3 Hauptprozeduren des Garbage Collectors

5.3.1 Modul-globale Variable

5.3.2 Prozedur ‘init mem’

5.3.3 Prozedur ‘switch_mem’

5.3.4 Prozedur ‘init_new_half’

5.3.5 Prozedur ‘traverse’

5.3.6 Prozedur ‘move_value’

5.3.7 Prozedur ‘valmem’

5.3.8 Prozedur ‘ars_malloc’

5.3.9 Prozedur ‘ars_vmalloc’

5.3.10 Utility-Prozeduren des Speichermanagers

6 ARS++ - Compiler: ACOMP

6.1 Zweck und Versionen des Compilers

6.2 Hauptfunktion ‘compile’

6.3 Kompilation einer Konstanten

6.4 Kompilation eines Symbols

6.5 Kompilation eines Makros

6.6 Kompilation eines ‘quote’-Ausdrucks

6.7 Kompilation einer ‘define’-Anweisung

6.8 Kompilation einer ‘set!’-Anweisung

6.9 Kompilation einer ‘lambda’-Abstraktion

6.10 Kompilation eines ‘if’-Konstruktes

6.11 Kompilation eines ‘let’-Konstruktes

6.12 Kompilation von Synthesen

6.12.1 Kompilation eines allgemeinen Funktionsaufrufs

6.12.2 Kompilation eines Funktionsaufrufs mit ‘apply’

6.12.3 Kompilation eines ‘call-with-current-continuation’Konstruktes

6.13 Kompilation eines ‘begin’-Konstruktes

6.14 Kompilation von Spracherweiterungen (Makros)

6.15 Kompilation eines ‘letrec’-Makros

6.16 Kompilation eines ‘cond’-Makros

6.17 Kompilation eines ‘case’-Makros

6.18 Kompilation eines ‘or’-Makros

6.19 Kompilation eines ‘and’-Makros

6.20 Kompilation eines ‘while’-Makros

6.21 Kompilation eines ‘do’-Makros

6.22 Kompilation von ‘defmacro’

6.23 Kompilation von Benutzermakros

6.24 Kompilation von ‘quit’, ‘evals’ und ‘load’

6.25 Hilfsfunktionen

6.25.1 Funktionen ‘comp-file’, ‘read-file’ und allg. Funktionen

6.25.2 Weitere Hilfsfunktionen des Compilers wie ‘comp’, ‘comp-exps’ und andere

6.26 Benutzerschnittstelle des Compilers

6.27 Hinweise zur Benutzung

Anhänge

A Das Lambda-Kalkül

A.1 Syntax eines Lambda-Ausdrucks

A.2 Begriffe und Regeln des Lambda-Kalküls

A.2.1 Assoziativitätsregeln

A.2.2 Gebundene und freie Variable

A.2.3 Alpha-Konvertierung

A.2.4 Beta-Reduktion

A.2.5 Eta-Reduktion

A.2.6 Y-Kombinator

A.3 Beispiele für Beta-Reduktion

A.3.1 Lambda-Kalkül-Programmierung in Scheme-Codierung

A.3.2 Auszuwertende Lambda-Ausdrücke in Scheme-Codierung

A.3.3 Basis-Abstraktionen in Scheme-Codierung

A.3.4 Anwendung mit Beta-Reduktion

B Gültigkeitsbereich von Namen

B.1 Interpretation von Namen

B.1.1 Dynamic Scope

B.1.2 Static Scope

B.1.3 Global Scope

B.1.4 Local Scope

B.2 Auswirkung der Art der Symbolinterpretation auf die Programmierung

B.2.1 Auswirkung von ”Dynamic Scope“ auf die Programmierung

B.2.2 Auswirkung von ”Static Scope“ auf die Programmierung

B.2.3 Verdeutlichung der Unterschiede von „dynamic scope“ und ”lexical scope“ anhand von Beispielen

B.3 WWW-Adressen

Nachwort

Biographische Daten zur Person des Autors

Literaturverzeichnis

Index

Verzeichnis der Fundamentalbegriffe

1 Abstraktion

2 Referenz

3 Synthese

4 Funktion

5 Nebeneffekte

6 Klasse von Funktionen

7 Modularisierung

8 Objekt-Orientierung

9 Klassenvariable

10 Instanz einer Klasse

11 Exemplar einer Klasse

12 Objekt

13 Instanzvariable

14 Methoden von Objekten

15 Attribute von Objekten

16 Pakete in Java

17 Definition von Variablen

18 Definition von Funktionen

19 Erzeugung von Objekten

20 Zuweisung von Werten

21 Testen von Werten

22 Einfache Auswahlstruktur

23 Allgemeine Auswahlstruktur

24 Wiederholung von Operationen

25 DOUNTIL-Struktur

26 DOWHILE-Struktur

27 Atom

28 Zusammengesetzte Daten

29 Listen

30 Dictionaries

31 Assoziative Listen

32 Hash-Tabellen

33 Vektoren

34 Abstraktion

35 Referenz

36 Synthese

37 Closure

38 Lexical Scope

39 Klasse von Funktionen

40 Klassenvariable

41 Instanz einer Klasse

42 Exemplar einer Klasse

43 Objekt

44 Instanzvariable

45 Methoden von Objekten

46 Attribute von Objekten

47 Special-Form in ARS++

48 Makros in ARS++

49 Etwas einen Namen geben (ARS++)

50 Lambda-Abstraktion in ARS++

51 Nebeneffekte in ARS++

52 Closures in ARS++

53 Bildung von Klassen in ARS++

54 Erzeugung eines Objektes in ARS++

55 Senden einer Botschaft an ein Objekt in ARS++

56 Bildung von Makros in ARS++

57 Lexical Scope

58 Indefinite Extent

59 Closure

60 Testen von Werten in ARS++

61 Einfache Auswahlstruktur (if)

62 Allgemeine Auswahlstruktur (cond)

63 Allgemeine Auswahlstruktur (case)

64 Wiederholungsstruktur (while)

65 Rekursion

66 Atom in ARS++

67 Listen in ARS++

68 Funktionen höherer Ordnung in ARS++

69 Dictionaries in ARS++

70 Assoziative Listen in ARS++

71 Sequentielle Programmierung in ARS++

72 Logische Abstraktionen in ARS

73 Numerische Abstraktionen in ARS

74 Abstraktionen für Listen in ARS

75 Relationale Abstraktionen in ARS

76 Funktionen Höherer Ordnung in ARS

77 Imperative Programmierung in ARS

78 Objekt-Orientierte Programmierung in ARS(A++)

79 Syntax eines Lambda-Ausdrucks

80 Assoziativitätsregel für die Abstraktion

81 Assoziativitätsregel für die Applikation

82 Gebundene und freie Variable

83 Alpha-Konvertierung. 382 84 redex

85 Beta-Reduktion

86 Eta-Reduktion

87 Y-Kombinator

88 Dynamic Scope

89 Static Scope

90 Lexical Scope III

91 Indefinite Extent II

92 Dynamic Extent

93 Global Scope

94 Local Scope

Tabellenverzeichnis

1.1 Liste der Ein/Ausgabe-Funktionen

1.2 Liste einiger Relationalen Operationen

4.1 Funktionen der Klassen des ARS-Interpreters

Abbildungsverzeichnis

2.1 Funktionsbegriff

2.2 Erweiterter Funktionsbegriff

2.3 Funktion mit Nebeneffekten

2.4 Klassenbegriff

2.5 Instanzbegriff

3.1 IFTHENELSE-Struktur

3.2 CASE-Struktur

3.3 DOUNTIL-Struktur

3.4 DOWHILE-Struktur

4.1 Paar-Struktur

4.2 “nil”

4.3 Liste mit einem Element

4.4 Liste mit zwei Elementen

4.5 Stuktur einer komplexen Liste

4.6 Wörterbuch oder assoziative Liste

1.1 Definition einer “closure”

1.2 Aufruf einer “closure”

2.1 A++

2.2 Vorgegebene Primitiv-Abstraktionen für A++

2.3 A++ mit vorgegebenen Primitiv-Abstraktionen

2.4 A++ mit primitiven Werten und Operationen sowie typischen Abstraktionen

4.1 Dictionary oder assoziative Liste

6.1 Klassenbegriff

6.2 Instanzbegriff

6.3 Klasse “account”

6.4 Konstruktor der Klasse “account”

6.5 Aufruf des Konstruktors “make-account”

6.6 Senden einer Botschaft an “acc1”

6.7 Ausführen der Methode “deposit”

6.8 Tierheim: Klassendiagramm

6.9 Bibliotheksverwaltung: Klassendiagramm

1.1 Struktur von ARS++ (erste Ausbaustufe)

1.2 Konstruktor der Klasse “account”

1.3 Aufruf des Konstruktors “make-account”

1.4 Senden einer Botschaft an “acc1”

1.5 Beantworten der Botschaft “deposit”

1.6 Implementierung einer Liste

1.7 Dictionary oder assoziative Liste

2.1 Struktur von ARS++ (zweite Ausbaustufe)

2.1 Bibliotheksverwaltung: Klassendiagramm

3.1 Eine Lösung des ‘Eight-Queens’-Problems

3.2 Multi-Tasking

4.1 Hauptfunktionen des ARS-Interpreters

4.2 Struktur der Funktion ‘ars-eval’

4.3 Funktion ars-apply

4.4 Funktion ‘make-closure’

4.5 Primitiv-Abstraktionen des ARS-Interpreters

1.1 ARS

1.2 ARSAPI

3.1 Datentypen in ARSAPI für Java

3.2 Struktur einer ‘Umgebung’ für Closures

4.1 Datentypen in ARSAPI für C

4.2 Struktur einer ‘Umgebung’ für Closures

5.1 ARSAPI für C++: Datentypen

5.2 Struktur einer ‘Umgebung’ für Closures

1.1 ARS++

1.2 Aufbau der AVIM-SECD-Maschine

1.3 Komplexe Alternativstruktur

1.4 Auflösung einer komplexen Alternativstruktur in ACOMP

1.5 Arbeiten mit Variablen in AVIM

1.6 Definition einer Umgebung in AVIM

1.7 Arbeiten mit Funktionen in AVIM

1.8 ‘Continuations’ in AVIM

1.9 Alternativ-Struktur in AVIM

1.10 Funktionsdefinition in AVIM

3.1 Erweitertes ‘Environment’-Konzept für ARSAPI

3.2 Struktur einer ‘Umgebung’ für CLAM’s

3.3 Kategorien von Funktionen in ARSAPI für C

3.4 CLAM: Verkapselung einer Abstraktion mit ihrer Umgebung

3.5 Erweitertes ARSAPI für C

6.1 Hauptfunktion von ACOMP

6.2 Makroauflösung in ACOMP

Listings

3.1 Grundlegende logische Abstraktionen

3.2 Anwendung der grundlegenden logischen Abstraktionen

3.3 Erweiterte logische Abstraktionen

3.4 Anwendung der erweiterten logischen Abstraktionen

3.5 Abstraktion ‘zero’

3.6 Abstraktion ‘one’

3.7 Abstraktion ‘two’

3.8 Abstraktion ‘zerop’

3.9 Anwendung der Abstraktion ‘zerop’

3.10 Abstraktion ‘three’

3.11 Abstraktion ‘compose’

3.12 Abstraktion ‘add’

3.13 Anwendung der Abstraktion ‘add’

3.14 Abstraktion ‘succ’

3.15 Anwendung der Abstraktion ‘succ’

3.16 Abstraktion ‘mult’

3.17 Anwendung der Abstraktion ‘mult’

3.18 Abstraktion ‘lcons’

3.19 Abstraktion ‘lcar’

3.20 Abstraktion ‘lcdr’

3.21 Anwendung der Basis-Operationen für Listen

3.22 Abstraktion ‘nil’

3.23 Beispiel für eine allgemeine Liste

3.24 Abstraktion ‘nullp’

3.25 Anwendung der Abstraktion ‘nullp’

3.26 Abstraktion ‘llength’

3.27 Anwendung der Abstraktion ‘llength’

3.28 Abstraktion ‘remove’

3.29 Anwendung der Abstraktion ‘remove’

3.30 Abstraktion ‘zeropair’

3.31 Abstraktion ‘pred’

3.32 Anwendung der Abstraktion ‘pred’

3.33 Abstraktion ‘sub’

3.34 Anwendung der Subtraktion

3.35 Abstraktion ‘equalp’

3.36 Anwendung der Abstraktion ‘equalp’

3.37 Abstraktion ‘gtp’

3.38 Anwendung der Abstraktion ‘gtp’

3.39 Abstraktion ‘ltp’

3.40 Anwendung der Abstraktion ‘ltp’

3.41 Abstraktion ‘gep’

3.42 Anwendung der Abstraktion ‘gep’

3.43 Abstraktion ‘Fakultaet’

3.44 Anwendung der Abstraktion ‘Fakultaet’

3.45 Abstraktion ‘sum’

3.46 Anwendung der Abstraktion ‘sum’

3.47 Abstraktion ‘compose’

3.48 Abstraktion ‘curry’

3.49 Abstraktion ‘map’

3.50 Anwendung der Abstraktion ‘map’

3.51 Abstraktion ‘mapc’

3.52 Abstraktion ‘filter’

3.53 Anwendung der Abstraktion ‘filter’

3.54 Abstraktionen ‘locate’ und ‘locatex’

3.55 Anwendung von ‘locate’ und ‘locatex’

3.56 Abstraktion ‘nth’

3.57 Anwendung der Abstraktion ‘nth’

3.58 Abstraktion ‘for-each’

3.59 Anwendung der Abstraktion ‘for-each’

3.60 Abstraktion ‘memberp’

3.61 Anwendung der Abstraktion ‘memberp’

3.62 Abstraktion ‘addelt’

3.63 Anwendung der Abstraktion ‘addelt’

3.64 Abstraktion ‘union’

3.65 Anwendung der Abstraktion ‘union’

4.1 Abstraktion ‘insert’

4.2 Anwendung der Abstraktion ‘insert’

4.3 Abstraktion ‘insertion-sort’

4.4 Anwendung der Abstraktion ‘insertion-sort’

4.5 Assoziative Listen in A++

4.6 Anwendung der Abstraktionen für assoziative Listen in A++

5.1 Abstraktion “while”

6.1 Erstes Beispiel: Klasse “account” für Bankkonten

6.2 Anwendung der Prozedur ‘konto’

6.3 Basisklasse für alle Klassen

6.4 Tierheim: Klasse ‘tier’

6.5 Tierheim: Klasse ‘hund’

6.6 Tierheim: Klasse ‘katze’

6.7 Tierheim: Klasse ‘tierheim’

6.8 Tierheim: Testlauf

6.9 Tierheim: Ausgabeprotokoll des Testlaufs

6.10 Basisklasse für alle Klassen

6.11 Bibliotheksverwaltung: Klasse ‘person’

6.12 Bibliotheksverwaltung: Klasse ‘author’

6.13 Bibliotheksverwaltung: Klasse ‘reader’

6.14 Bibliotheksverwaltung: Klasse ‘book’

6.15 Bibliotheksverwaltung: Klasse ‘library’

6.16 Bibliotheksverwaltung: Testlauf

6.17 Bibliotheksverwaltung: Ausgabeprotokoll des Testlaufs

8.1 Abstraktion ‘ndisp!’

8.2 Abstraktion ‘bdisp!’

8.3 Abstraktion ‘ldisp!’

8.4 Testen des Interpreters

8.5 Testen des Interpreters

8.6 Initialisierungsdatei für den ARS-Interpreter: ‘init.ars’

1.1 Etwas einen Namen geben

1.2 Lambda-Abstraktion

1.3 Bildung einer Funktion mit Namensvergabe

1.4 Anwendung einer Funktion I

1.5 Anwendung einer Funktion II

1.6 Basisklasse für alle Klassen

1.7 Basisklasse “account” für Bankkonten

1.8 Klasse “accounti” für zinsbringende Konten

1.9 Anwendung der drei Klassen

1.10 Einfacher Makro

1.11 Anwendung des Makros

1.12 Applikation

1.13 Globale Variable

1.14 Lokale Variable

1.15 Makro “letrec”

1.16 Special-Form “named-let” in Scheme

1.17 Übersetzung eines ‘named-let’ in ARS++

1.18 Erzeugung von Objekten

1.19 Zuweisung von Werten

1.20 Verknüpfung von Prädikaten

1.21 Einfache Auswahlstruktur

1.22 Allgemeine Auswahlstruktur (cond)

1.23 Allgemeine Auswahlstruktur (case)

1.24 Wiederholungsstruktur: Summe bis 100

1.25 Wiederholungsstruktur: Fakultät

1.26 Wiederholungsstruktur: Fakultät mit ‘do’

1.27 Rekursion

1.28 Symbol-bezogene Bibliotheksfunktionen

1.29 Auswahl von numerischen Bibliotheksfunktionen

1.30 Auswahl von zeichen-orientierten Bibliotheksfunktionen

1.31 Auswahl von zeichenketten-orientierten Funktionen

1.32 Einfache Ausdrücke

1.33 Zusammengesetzte Ausdrücke

1.34 Ein Paar

1.35 Prädikat: “pair?”

1.36 Prädikat: “atom?”

1.37 Konstruktor für ein Paar “cons”

1.38 Selektor für das erste Element eines Paares

1.39 Selektor für das zweite Element eines Paares

1.40 Modifikator für das erste Element eines Paares

1.41 Modifikator für das zweite Element eines Paares

1.42 Die leere Liste

1.43 Einfache Listen

1.44 Listen-Prädikat: “list?”

1.45 Listen-Prädikat: “null?”

1.46 Konstruktor für eine Liste “list”

1.47 Die Funktionen “cons” und “list”