Programmieren lernen mit A++: Funktional programmieren in Python und Java

Von Georg P. Loczewski

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 werden die Programmiersprachen Python und Java vorgestellt und es wird gezeigt, wie A++-orientierte Programmierung in diesen Sprachen angewandt werden kann. Umfangreiche Fallstudien werden als Hilfe zum Erlernen der Programmierung angeboten.

Ein zur Verfügung gestellter Interpreter soll dabei behilflich sein, das Gelernte anzuwenden und zu testen.

Eine Einführung in das Lambda-Kalkül von Alonzo Church, das die theoretische Grundlage von A++ darstellt, ist im Anhang enthalten.

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.

• Sprache: Deutsch
• Herausgeber: tredition
• Erscheinungsdatum: 7. Mai 2018
• ISBN: 9783746932019

Georg P. Loczewski

Georg P. Loczewski (*1939 in Schönlanke in Pommern) flüchtete als Kind mit seiner Mutter und Schwester nach Reit im Winkl in Bayern. Von 1959 bis 1964 studierte er Philosophie und Theologie in Reisach am Inn (Aszese und Mystik im Noviziat der Unbeschuhten Karmeliten) und in Regensburg (Philosophisch-Theologische Hochschule). Danach studierte er einige Semester Physik an der Technischen Hochschule München und wechselte dann in das Berufsleben, in dem er von 1970–1998 auf dem Gebiet der Informatik als Ausbilder für systemnahe Programmierung und Methodik der Programmierung, als Education Consultant und als Systemprogrammierer in Deutschland und in den USA für die Computerfirmen Honeywell, Honeywell Bull und Bull arbeitete. Im Jahr 1970 gründete er eine Familie, aus der zwei Söhne hervorgingen. 1980 veröffentlichte er das Buch Logik der Strukturierung von Programmen im R. Oldenbourg Verlag. Später folgten die Bücher Programmierung PUR (2003) und A++, The Smallest Programming Language in the World (2005). Im Jahre 1990 kehrte er nach Deutschland zurück und arbeitete dort für die Computer Firma 'Bull GmbH' als Systemprogrammierer. Im Ruhestand hat er für den S. Toeche-Mittler-Verlag und die internationale Versandbuchhandlung derselben Firma in Darmstadt die E-Commerce-Plattform aufgebaut (http://www.net-library.de). Während des größten Teils seines Berufslebens und danach hat er sich für katholische Spiritualität interessiert, besonders für die Spiritualität des hl. Johannes v. Kreuz. Mit seiner Familie hat er eine enge Beziehung zu Mönchen einer Kartause in der Schweiz aufgebaut .In den letzten 25 Jahren hat er mehrere kleine Schriften verfasst, die der kontemplativen Spiritualität gewidmet sind, die jedoch nicht veröffentlicht wurden. In den Jahren ab 2016 veröffentlichte er religiöse Kleinschriften zu nächst im 'Bernardus-Verlag, Aachen' und danach im Verlag 'tredition-GmbH, Hamburg'. Auf seiner Home-Page http://www.alpha-bound.de befinden sich mehrere Web-Publikationen. Hingewiesen sei ganz besonders auf den 'Multi-Lingual Bible Server', der die gesamte Bibel in 7 verschiedenen Sprachen anbietet, darunter auch Russisch, Griechisch und Hebräisch. Seine folgenden Web-Sites sind der in den Büchern präsentierten Spiritualität gewidmet: www.alpha-bound.de, www.lambda-bound.de, www.logos-bound.de, www.alpha-bound.org. Seine folgenden Web-Sites Seine sind der Informatik gewidmet: www.aplusplus.net, www.lambda-bound.com . (Buchindex zum Download: logos-bound.de)

Buchvorschau

Programmieren lernen mit

A++

Georg P. Loczewski

Programmieren lernen mit A++

Funktional programmieren in Python und Java

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

IMPRESSUM

Copyright © 2018 Georg P. Loczewski

Programmieren lernen mit A++

1. Auflage 2018 –Hamburg

Verlag: tredition GmbH

2. Auflage 2018 –Hamburg

Verlag: tredition GmbH

ISBN

978-3-7469-3199-9 (Paperback)

978-3-7469-3200-2 (Hardcover)

978-3-7469-3201-9 (e-Book)

Verlag & Druck: tredition GmbH

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 Ursula

und meinen Söhnen Thomas und Johannes

in Liebe gewidmet

Inhaltsverzeichnis

Vorwort

IGrundlagen

1Einführung

1.1 Konstitutive Prinzipien in A++

Abstraktion

Referenz

Synthese

Closure

Lexical Scope

2Sprachdefinition

2.1 Syntax und Semantik von A++

Anmerkungen zur Syntax:

2.2 Beispiele zur Syntax von A++

Beispiele zur Abstraktion 1. Alternative in 2.2

Beispiele zur Abstraktion 2. Alternative in 2.2

Beispiele zur Referenz 2.3

Beispiele zur Synthese 2.4

2.3 A++ Erweiterung

Syntax von A++ mit vorgegebenen Primitiv-Abstraktionen

Beispiele zu den Erweiterungen in A++

3Erste Entfaltung von A++

3.1 Programmierstil in A++

3.2 Grundlegende Logische Abstraktionen

Abstraktionen ‘true’ und ‘false’

Abstraktionen ‘lif’

3.3 Erweiterte Logische Abstraktionen

3.4 Numerische Abstraktionen

Abstraktion für die Zahl ‘0’

Abstraktion für die Zahl ‘1’

Abstraktion für die Zahl ‘2’

Abstraktion für das Prädikat ‘zerop’

Abstraktion für die Zahl ‘3’

Utility-Abstraktion ‘compose’

Abstraktion für die Addition

Abstraktion für die Inkrementierung

Abstraktion für die Multiplikation

3.5 Abstraktionen für Listen

Abstraktion für den Konstruktor

Abstraktion für den Selektor ‘lcar’

Abstraktion für den Selektor ‘lcdr’

Anwendung der grundlegenden Operationen für Listen

Abstraktion für das Ende einer Liste

Abstraktion für das Prädikat ‘nullp’

Abstraktion für die Längenabfrage

Abstraktion zum Entfernen eines Objektes aus einer Liste

3.6 Erweiterte Arithmetische Abstraktionen

Abstraktion für ‘zeropair’

Abstraktion für die Dekrementierung

Abstraktion für die Subtraktion

3.7 Relationale Abstraktionen

Abstraktion für das Prädikat ‘gleich’

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

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

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

3.8 Funktionen Höherer Ordnung

Abstraktion ‘compose’

Abstraktion für die ‘curry’-Funktion

Abstraktion für die Abbildung einer Liste

Abstraktion für die ‘curry map’-Funktion

Abstraktion für die Auswahl aus einer Liste

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

3.9 Mengen-Operationen

Abstraktion für das Prädikat ‘memberp’

Abstraktion für das Hinzufügen eines Elementes

Abstraktion für die Vereinigung von Mengen

4Erste Anwendung von A++

4.1 Utility-Abstraktionen

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

Abstraktion für die Sortierung

4.2 Rekursion

Abstraktion für die Berechnung der Fakultät

Abstraktion für die Summation

Abstraktion für den Zugriff auf ein Element einer Liste

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

4.3 Imperative Programmierung in A++

Die Abstraktion ’while’ in A++

5Objekt-Orientierte Anwendung von A++

5.1 Einleitung

Bildung von Klassen

Instanzen von Klassen

Beispiele für Objekt-orientierung in A++

5.2 Erstes Beispiel zur Objektorientierung in A++

Konstruktor für Objekte der Klasse account

Erzeugung des Objektes acc1 durch Aufruf von make-account

Senden der Botschaft deposit an das Objekt acc1

Ausführen der Funktion deposit

Detaillierter Code in A++

Anmerkungen zu dem ersten Beispiel zur Objektorientierung

Anmerkungen zum Aufruf der Funktion ‘konto’

5.3 Zweites Beispiel zur Objektorientierung in A++

Anmerkung zu den einzelnen Klassen

Beziehungen zwischen den Klassen

Zusammenfassung

5.4 Drittes Beispiel zur Objektorientierung in A++

Anmerkung zu den einzelnen Klassen

6Abstraktion, Referenz und Synthese im Detail

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

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

Abstraktion von ‘add’ (1)

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

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

Abstraktion von ‘compose’

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

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

Abstraktion von three:

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

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

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

Abstraktion von two:

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

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

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

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

Synthese von mult und ‘two three’

Abstraktion von mult:

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

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

Abstraktion von compose:

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

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

Abstraktion von two:

Abstraktion von three:

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

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

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

Synthese vom inneren (lambda(x0) …) und ‘x1’

Synthese von (lambda(x0) …) und ‘(x(x(x x1)))’

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

7Infrastruktur für A++

7.1 Support-Funktionen

Abstraktion für die Ausgabe einer Zahl

Abstraktion für die Ausgabe eines boole’schen Wertes

Abstraktion für die Ausgabe von Listen

7.2 A++ Interpreter

Linux

MS-Windows

Programmbeendigung

7.3 Initialisierungsdatei für den ARS-Interperter

7.4 WWW-Adressen

8Erweiterung von A++

8.1 ARS++

8.2 ARSAPI

II ARS und Pyhon

9Programmierung in Python

9.1 Allgemeine Syntax von Python

9.2 Wichtige Abstraktionsmechanismen

Bildung von Funktionen

Bildung von Klassen

Bildung von Modulen

9.3 Operationen in Funktionen

Definition von Variablen

Definition von Funktionen

Erzeugung von Objekten

Zuweisung von Werten

Testen von Werten

Wiederholung von Operationen

Rekursion

Ein-/Ausgabe-Operationen

Arithmetische Operationen

Relationale Operationen

Boolesche Operationen

9.4 Grundlegende Datentypen

Atome

Listen

Methoden für Listenobjekte

Hilfsfunktionen für Listen

9.5 Dictionaries

Methoden für Assoziative Listen

Hash-Tabellen

9.6 Besonderheiten in Python

10 ARS-Interpreter in Python

10.1 Einleitung

Syntax eines Lambda-Ausdrucks in EBNF-Notation:

Komponenten des Interpreters

10.2 Klasse X

10.3 Globale Variable

10.4 Klasse ARSSymbol

10.5 Klasse ARSToken

10.6 Klasse für den Parser: ARSParser

10.7 Klasse ARSClosure

10.8 Funktionen für die Auswertung von Ausdrücken

10.9 Klasse Interpreter

10.10 Austesten des Interpreters

10.11 Quellcode des Interpreters

10.12 Kompatibilitäts Modul für Listen

III ARS und Java

11 Programmierung in Java

11.1 Zweck und Umfang der Einführung in Java

11.2 Wichtige Abstraktionsmechanismen

Etwas einen Namen geben

Bildung von Klassen

11.3 Closures

11.4 Operationen in Funktionen

Allgemeine Grundfunktionen

Praktische Konkretisierung der allgemeinen Grundfunktionen

Bildung von Funktionen

11.5 Grundlegende Datentypen

Atom

Listen

Verarbeitung von Listen

Implementierung von Listen in Java

Dictionaries

11.6 Besonderheiten in Java

Fehler-Behandlung mit try und catch

Threads

11.7 Alternative Implementierung von Closures in Java

Datentypen-Überblick

Umgebung einer Lambda-Abstraktion

Klasse LClosure

Anwendungsbeispiele

12 ARS-Interpreter in Java

12.1 Einleitung

Syntax eines Lambda-Ausdrucks in EBNF-Notation:

Funktion und Struktur des Interpreters

12.2 Klasse für Symbole: Symbol

12.3 Klasse für Token: ARSToken

12.4 Klasse für den Parser: ARSParser

12.5 Klasse für Closures: ARSClosure

12.6 Klasse für den Evaluator: ARSEval

12.7 Klasse für die Fehlerbehandlung: ARSException

12.8 Klasse: ARSInterpreter

13 Komplette Anwendung in Java: OntoSimula

13.1 Einleitung

Simulation des Lebens von fünf Philosophen

Als ‘applet’ im Internet ausführbar

Detailliertes Szenario

13.2 Quellen für die Entwicklung der Fallstudie

13.3 Dynamisches Objektsystem für Java

Überblick

Klasse LJoops

Klasse LJoopsError

Klasse LJClasstable

Klasse LJclass

Klasse LJobject

Testprogramm für LJoops

13.4 Lambda-Klassen in Java

Überblick

13.5 Applet-Steuerklasse: PhilGraph

Darstellung auf dem Bildschirm

Ausführung in der Java-VM

13.6 Haupt-Anwendungsklasse OntoSimula

Dynamische Klassen

13.7 Haupt-Graphikklassen

Klasse für das Schloss: PhilCastle

Klasse für die Bedieneroberfläche

13.8 Statische Klassen für Sachen

Basis-Klasse ElementD

Klasse Chopstick

Klasse Room

13.9 Klassen für graphische Objekte

Basisklasse ImageObjectD

Klasse PersonImage

Klasse ChopstickImage

Hilfsklasse Semaphore

13.10 Methoden zur Auswahl des Verhaltensmusters

Methoden zur Auswahl des Verhaltensmusters für Aristoteles

Methoden zur Auswahl des Verhaltensmusters für Heraklit

Methoden zur Auswahl des Verhaltensmusters für Parmenides

Methoden zur Auswahl des Verhaltensmusters für Plato

Methoden zur Auswahl des Verhaltensmusters für Sokrates

13.11 Verhaltensmuster für alle Philosophen

Verhaltensmuster für heroische Einsatzbereitschaft

Verhaltensmuster für hohe Einsatzbereitschaft

Verhaltensmuster für normale Einsatzbereitschaft

Verhaltensmuster für gemäßigte Einsatzbereitschaft

Verhaltensmuster bei Krankheit

13.12 Spezielle Verhaltensmuster für Heraklit

Verhaltensmuster für heroische Einsatzbereitschaft

Verhaltensmuster für hohe Einsatzbereitschaft

Verhaltensmuster für normale Einsatzbereitschaft

13.13 Aktivitäten für alle Philosophen

Denken

Holen der Chopsticks

Essen

Zurückgeben der Chopsticks

Schlafen

Krankwerden

Altern

13.14 Spezielle Aktivitäten für Heraklit

Altern

13.15 Spezielle Aktivitäten für Sokrates

Holen der Chopsticks

Zurückgeben der Chopsticks

Altern

13.16 Spezielle Klasse für den Seins-Akt aller Seienden

13.17 Utility Klasse für die Verwaltung der Chopsticks

Anhänge

ADas Lambda-Kalkül

A.1 Syntax eines Lambda-Ausdrucks

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

Assoziativitätsregeln

Gebundene und freie Variable

Alpha-Konvertierung

Beta-Reduktion

Eta-Reduktion

Y-Kombinator

A.3 Beispiele für Beta-Reduktion

Lambda-Kalkül-Programmierung in Scheme-Codierung

Auszuwertende Lambda-Ausdrücke in Scheme-Codierung

Basis-Abstraktionen in Scheme-Codierung

Anwendung mit Beta-Reduktion

BGültigkeitsbereich von Namen

B.1 Interpretation von Namen

Dynamic Scope

Static Scope

Global Scope

Local Scope

B.2 Auswirkung der Art der Symbolinterpretation auf die Programmierung

Auswirkung von „Dynamic Scope" auf die Programmierung

Auswirkung von „Static Scope" auf die Programmierung

Verdeutlichung der Unterschiede von „dynamic scope und „lexical scope anhand von Beispielen

CErgänzungen zu OntoSimula

C.1 OntoSimula in Scheme

C.2 Philosophischer Hintergrund zu OntoSimula

Einleitung

Abbildung der Prinzipien in OntoSimula (Java)

Abbildung der Prinzipien in OntoSimula (Scheme)

Schlusswort

Biographische Daten zur Person des Autors

Verzeichnis der Fundamentalbegriffe

Abbildungsverzeichnis

Listings

Literaturverzeichnis

Index

Vorwort

Einleitung

Dieses Buch ist basiert auf dem 1032-seitigen Buch ‘Programmierung pur’(Siehe [16].), das in der 2. erweiterten Auflage von demselben Autor im Verlag S.Toeche-Mittler in Darmstadt im Jahre 2003 verffetlicht wurde. Die 1. Auflage erschien im Jahre 2002 unter derselben ISNB: 3-87820-108-7 .

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

1. In A++ Die kleinste Programmiersprache der Welt [17] 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++ [20] 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: [18]!

3. In dem 3. Buch A++ und systemnahe Programmiersprachen [19] 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++ [21] 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: 7.4 auf Seite 85.

Zweck des Buches

In diesem kleinen Büchlein, geht es primär darum an der Programmierung interessierten Leserinnen und Lesern ein Instrument vorzustellen, mit dem sie sehr schnell und sehr effizient Programmieren lernen können, ohne sich schon für eine der populären, voll-ausgebauten Programmiersprachen entscheiden zu müssen und ohne einen großen Kostenaufwand zu haben.

Dass es möglich ist, mit den Denkmustern von A++ in anderen Programmiersprachen produktiv sein zu können wird in diesem Buch gezeigt, indem nach einer Einführung in die Programmiersprachen Python und Java die A++-orientierte Programmierung in diesen zwei Sprachen vorgestellt wird.

Diese zwei ausgewählten Programmiersprachen gehören zu der Gruppe der höheren Programmiersprachen (’higher level languages’), die sich besonders fr anwendungsorientierte Programmierung eignen (application programming).

Im Unterschied dazu gibt es sogenannte systemnahe Programmiersprachen wie C und C++, die sich besonders fr Systemprogrammierung eignen (Betriebssysteme und Systemhilfsprogramme). Diesen Programmiersprachen im Zusammenhang mit A++ widmet sich das Buch A++ und systemnahe Programmiersprachen. (Siehe:[19]).

Theoretische Grundlagen von A++

Das Wesentliche der Programmierung

A++ ist die kleinste Programmiersprache der Welt, deren Sinn es ist einzig das Wesentliche der Programmierung darzustellen, und zwar in einer Form dass damit gearbeitet werden kann, dass man es einüben kann. So soll A++ hilfreich sein beim Erlernen des Programmierens ganz allgemein, aber auch beim Erlernen von konkreten Programmiersprachen.

Elementarteilchen der Programmierung

In A++ werden die Elementarteilchen der Programmierung in reinster Form sichtbar gemacht. Man kann diese gründlich studieren, den richtigen Umgang mit ihnen einüben und sich so die wichtigsten Rüstzeuge der Programmierung aneignen.

Vereinfachung der Programmierung

In dem Bemühen, Programmierung auf das Wesentliche zu reduzieren, geht es darum, Lernende zu bewahren, sich von einer Unzahl von Vorschriften und Regeln einer bestimmten Programmiersprache die Programmierung an sich vergraulen zu lassen.

Energien, die in den meisten Sprachen für die Beherrschung und das Einhalten der Syntax aufgebracht werden müssen, kommen in A++ der wichtigeren Aufgabe der logischen Bewältigung des zu lösenden Problems zugute.

Einfache, umfassende und mächtige Denkmuster

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.

Verallgemeinerung des Lambda-Kalküls

Der Name A++ ist eine Abkürzung von Abstraktion plus Referenz plus Synthese. Hiermit werden die drei Prinzipien von A++ benannt, die gleichzeitig ihr einziger Inhalt sind. Diese Prinzipien stellen eine Verallgemeinerung der Grundoperationen des Lambda-Kalküls von Alonzo Church dar. Das Lambda-Kalkül ist ein mathematisch-logisches System, das 1941 von dem Logiger Alonzo Church in seinem Buch: ‘The Calculi of Lambda Conversion’ der Welt vorgestellt wurde. Siehe hierzu unsere kurze Zusammenfassung im Anhang A auf Seite 277.

Während das Lambda-Kalkül der Funktionalen Programmierung ihre theoretische Grundlage liefert, ist A++ in der Lage eine theoretische Grundlage für die drei bekanntesten Paradigmen der Programmierung zu liefern, d.h. für die funktionale, die objekt-orientierte und die imperative Programmierung.

Verallgemeinerung der Grundoperationen des Lambda-Kalküls:

•Abstraktion: Etwas einen Namen geben

•Referenz: Auf etwas mit seinem Namen Bezug nehmen

•Synthese: Aus zwei oder mehr Dingen etwas Neues erzeugen

Die Primitiv-Operationen von A++ gehen inhaltsmäßig über die Grundoperationen des Lambda-Kalküls hinaus, indem ihnen in der Anwendung in einem Programm jedwede Einschränkung genommen wird.

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