imported>Sotel: /* Beamtendeutsch ersetzt */

2025-06-06T11:01:15Z

Beamtendeutsch ersetzt

Neue Seite

{{Infobox Programmiersprache
|Name =
|Paradigma = [[Stapelspeicher|stapelorientiert]]
|Erscheinungsjahr = ca. 1970
|Entwickler = [[Charles H. Moore]]
|Typisierung = typenlos
|Implementierung =
|Dialekte = FORTH-79, FORTH-83, ANS FORTH, Forth-2012<ref>http://www.forth200x.org</ref>
|Beeinflusst_von = [[Burroughs Corporation|Burroughs]] Large Systems, [[Lisp]], [[APL (Programmiersprache)|APL]], [[Assemblersprache|Assembler]]
|Beeinflusste = [[STOIC (Programmiersprache)|STOIC]], [[Factor]], [[PostScript]], [[Reverse Polish LISP|RPL]], [[REBOL]]
}}
'''Forth''' ist eine [[Imperative Programmierung|imperative]], [[Stapelspeicher|stackbasierte]] [[Programmiersprache]] in [[Umgekehrte polnische Notation|umgekehrter polnischer Notation (UPN)]], der [[Mathematische Notation#Postfixnotation|Postfixnotation]]. Ein ''Forth-System'' enthält ein [[Betriebssystem]] zum Ablauf und eine [[Integrierte Entwicklungsumgebung|Entwicklungsumgebung]] zur Erstellung von Forth-Programmen. Daher nennt man ein tatsächlich [[Implementierung|implementiertes]] Forth auf einem Rechner ein '''Forth-System'''. Viele Versionen generieren heute, so wie in anderen Programmiersprachen auch, hochoptimierten [[Maschinencode]].

== Entstehungsgeschichte ==
[[Charles H. Moore]] entwickelte Forth in den Jahren vor 1969 aus einem selbstgeschriebenen Mini-[[Interpreter]]. Dieser Interpreter enthielt bereits viele Eigenschaften der späteren Programmiersprache, war aber auf ein darunterliegendes [[Betriebssystem]] angewiesen. Moore benutzte ihn als [[Makro]]sprache für Programme, die er in [[Fortran]], [[ALGOL]], [[PL/I]] und [[Assembler (Informatik)|Assembler]] schrieb. Die Computertechnik dieser Zeit veränderte sich gerade von [[Großcomputer]]n, die im [[Stapelverarbeitung|Batchbetrieb]] arbeiteten hin zu [[Minicomputer]]n, die auch interaktives Arbeiten zuließen. 1968 schrieb Moore neben seiner eigentlichen Arbeit für einen IBM-1130-Minicomputer schließlich ein [[Schachprogramm]], das er zuvor in Algol kodiert hatte, in seine Programmiersprache um. Das Schachprogramm war dadurch deutlich einfacher zu portieren und Moore nannte seine Sprache nun das erste Mal ''FORTH''. Ursprünglich sollte die Sprache ''FOURTH'' heißen, weil sie eigentlich für die Computer der vierten Generation vorgesehen war, welche erwartungsgemäß als [[Mikrocomputer]] vertrieben wurden. Das Betriebssystem, auf dem Moore programmierte, ließ jedoch nur Dateinamen mit einer Länge von fünf Buchstaben zu, weshalb er sich für das [[Homophon]] ''FORTH'' entschied.<ref>{{Internetquelle | url=http://worrydream.com/refs/Moore%20-%20Forth%20-%20The%20Early%20Years.pdf | titel=Forth – The Early Years | autor=Charles Moore | datum=1991 | zugriff=2016-05-05 }}</ref>

Die Eigentümlichkeit einer umfassenden Lösung aus Programmiersprache und Betriebssystem lässt sich gut aus der Entstehungsgeschichte<ref>[https://www.forth.com/resources/forth-programming-language/ Entstehungsgeschichte von Forth]</ref> heraus erklären. Moore hatte zur Steuerung des 11-Meter-[[Radioteleskop]]s des [[National Radio Astronomy Observatory]] (NRAO) auf dem [[Kitt Peak]] in [[Arizona]] zwei [[Honeywell Serie 16|Honeywell]]-Rechner ohne geeignete [[Software]] zur Verfügung, einen 16 kB [[DDP-116]] und einen 32 kB [[H316]]. Er hatte sich vorgenommen, alle notwendigen Komponenten selbst zu programmieren, die für eine komfortable Programmierung und den sicheren Betrieb der Rechner notwendig sind. Hierzu gehören ein [[Betriebssystem]], eine [[Höhere Programmiersprache|Hochsprache]] und eine [[Integrierte Entwicklungsumgebung|Entwicklungsumgebung]]. All diese Komponenten wurden innerhalb eines einzelnen Programms verwirklicht – dem Forth-System. Beide Computer waren für die Steuerung des Teleskops und seiner wissenschaftlichen Instrumente verantwortlich, sie überwachten die Positionierung und die Nachführung, das Sammeln und Aufzeichnen der Daten auf [[Magnetband]], und unterstützten ein interaktives [[Terminal (Computer)|Grafikterminal]] (Tektronix 4002A<ref>https://ub.fnwi.uva.nl/computermuseum//tek4002a.html</ref>) auf dem die Astronomen die aufgezeichneten Daten analysieren und als Hardcopy ausdrucken konnten. Der [[Multitasking]]-Charakter des Systems erlaubte den gleichzeitigen Ablauf dieser Funktionen, ohne dass dabei Störungen oder Laufzeitkonflikte auftraten. Insgesamt funktionierte das System so gut, dass [[Astronom]]en aus der ganzen Welt sich dafür interessierten und eine Kopie haben wollten. Seine Anwendung verbreitete sich schnell, und 1976 war Forth als Standardsprache durch die [[Internationale Astronomische Union]] angenommen.

[[Datei:FORTH3.jpg|mini|Populäre Bücher über Forth aus der Zeit des [[Sinclair ZX81|ZX81]] und des [[Sinclair ZX Spectrum|Spectrum]]]]

Die Vorgehensweise einer sogenannten „All-in-one-Lösung“ ist jedoch ein Sonderweg von Forth geblieben. Selbst Programmiersprachen wie [[Smalltalk (Programmiersprache)|Smalltalk]] oder [[Self (Programmiersprache)|Self]] gehen (in der Regel) nicht so weit, auch das Betriebssystem zu ersetzen. Obwohl dies möglich wäre, wünscht man sich meist [[Plattformunabhängigkeit|Portabilität]]. Auch die Programmiersprache [[Oberon (Programmiersprache)|Oberon]], die im Rahmen des [[Ceres (Computersystem)|Ceres]]-Systems entwickelt wurde, ist unabhängig von diesem erhältlich. Ähnlich wie Forth hatte nur noch das Programmiersprache/Betriebssystem-Paket [[L2 (Betriebssystem)|EUMEL]] und [[ELAN (Programmiersprache)|ELAN]] verfahren. Normalerweise werden die oben genannten Komponenten getrennt voneinander konzipiert und entwickelt.

== Forth-System ==
Ein vollständiges Forth-System kann bereits mit wenigen [[Kilobyte]] Speicherbelegung realisiert werden. Diese Eigenschaft war zur Zeit der Entstehung außerordentlich wichtig, da die Rechner damals verhältnismäßig wenig [[Random-Access Memory|RAM]] zur Verfügung hatten. Außerdem ist der eigentliche Kern des Forth-Systems sehr klein und der Rest des Systems bereits selbst in Forth definiert. Eine Portierung des Forth-Systems auf andere [[Prozessor]]en ist dadurch erheblich einfacher. Diese positive Eigenschaft hat Forth in den späten 1970er Jahren eine relativ große Verbreitung beschert.

Heute macht dies Forth zu einer [[Höhere Programmiersprache|Hochsprache]], die besonders zur Programmierung verschiedenster [[Mikrocontroller]] geeignet ist. Zur Entwicklung werden dabei aber kombinierte Systeme benutzt, bei denen der [[Zwischencode]] auf einem [[Hostrechner|Host-PC]] vorkompiliert und lediglich das Ergebnis im Mikrocontroller des [[Client]]s abgelegt wird. Dadurch können einige interaktive Funktionen des Forth-Systems entfallen und der [[Quelltext|Quellcode]] kann dabei umfassender [[Kommentar (Programmierung)|kommentiert]] werden.

Die wesentlichen Elemente der internen Forth-Architektur sind die beiden [[Stapelspeicher|Stapel]] (''Data-Stack'' und ''Return-Stack''), ein kleiner Satz [[Register (Computer)|Register]], die gegebenenfalls unabhängig von der [[Hardware]] simuliert werden, und das ''Dictionary'', eine [[Sprungtabelle]], die den [[Token (Übersetzerbau)|Token]] mit der jeweils aufzurufenden [[Funktion (Programmierung)|Funktion]] verknüpft. Das auf dem Stapel abgelegte Datenwort wird als ''Zelle'' bezeichnet, wobei diese 16, 32 oder 64 Bit groß sein kann. Überdies kann das ''Dictionary'' in mehrere ''Vocabularies'' nach Bedarf aufgeteilt werden. Das Forth-System selbst ist als [[virtuelle Maschine]] realisiert. Alle [[Anweisung (Programmierung)|Anweisungen]] und mathematischen Ausdrücke werden in umgekehrter polnischer Notation ([[Umgekehrte polnische Notation|UPN]]) formuliert. Dies ergibt sich einfach daraus, dass das Forth-System für jeden Eingabewert zunächst prüft, ob dieser im Dictionary vorhanden ist. Ist dies der Fall, wird die entsprechende Funktion aufgerufen, die dann auf alle bisher getätigten Eingaben zugreifen kann. Wenn der Wert nicht im Dictionary vorhanden ist, wird er als Zahlenwert oder [[Zeichenkette]] interpretiert. Nachfolgende Eingaben sind in beiden Fällen zu diesem Zeitpunkt noch nicht eingelesen und haben daher auf den Programmablauf noch keine Auswirkung. Man kann daher auch, wie zum Zeitpunkt der Entstehung üblich, den Eingabedatenstrom leicht durch ein sequentielles Medium, wie z. B. einen [[Lochkarte]]nstapel oder ein Magnetband, realisieren.

Forth hat zwei wesentliche Eigenschaften, die es von vielen anderen Programmiersystemen seiner Zeit unterscheiden:

* Forth war von Beginn an [[Public Domain]]
* Forth ist selbstkompilierend und erlaubt dabei dem Anwender direkten Zugriff auf den [[Compiler]], wodurch die Befehlsstruktur beliebig erweitert werden kann

=== Programmierung in Forth ===
Die Programmierung in Forth unterscheidet sich grundlegend von anderen Sprachen. In Forth gibt es keinen Unterschied zwischen integrierten und programmierten Funktionen (sog. ''Wörtern''), wohl aber einen funktionalen Kern von Wörtern (Primitiva), die direkt in Maschinencode implementiert sind. Es laufen auch keine unmittelbaren Routinen ab, stattdessen wird die Sprache um zusätzliche ''Wörter'' erweitert. Der Start eines Programms entspricht in Forth dem Aufruf eines ''Wortes'', das somit die Hauptroutine des Programms darstellt. Da auch der [[Compiler]] dadurch erweitert wird, indem man ''Wörter'' definiert, die in der Entwicklungsumgebung ablaufen und damit den Zwischencode unmittelbar manipulieren, führt das zu einer Flexibilität, die nur mit wenigen anderen Hochsprachen zu erreichen ist.

=== Beispiel eines UPN-Ausdrucks ===
Für die Berechnung des [[Ausdruck (Programmierung)|Ausdrucks]] <code>(5 + 3) * (7 + 2)</code> wird in Forth die folgende Sequenz eingegeben:
<pre>5 3 + 7 2 + * .</pre>

Die Verarbeitung des Ausdrucks erfolgt bereits beim Lesen. Der Eingabestring wird von Leerzeichen in ''Wörter'' unterteilt. Das Wort „5“ ist normalerweise nicht im ''Wörterbuch'' vorhanden, es wird als Zahl interpretiert, das heißt, ihr Wert (hier 5) wird auf den Value-Stack gelegt. Gleiches gilt für das Wort „3“. Das nun folgende Wort „+“ ist hingegen im ''Wörterbuch'' vorhanden. Es wird daher die entsprechende Funktion aufgerufen. Diese Funktion entfernt die obersten beiden Werte vom Stapel, addiert sie und legt das Ergebnis zurück auf den Stapel. Die kleine „+“-Funktion ist üblicherweise in der jeweiligen [[Maschinensprache]] realisiert. Auf dem Stapel liegt nun die Zahl 8. Das nächste Wort ist „7“, es wird die Zahl 7 auf den Stapel gelegt. Danach folgt das Wort „2“, hier landet die Zahl 2 auf dem Stapel. Als Nächstes wieder das Wort „+“, wodurch erneut die Additionsfunktion aufgerufen wird. Auf dem Stapel liegt nun zuoberst die Zahl 9, darunter die Zahl 8. Danach wird das Wort „*“ gelesen und im Wörterbuch gefunden; die zugehörige Funktion nimmt die beiden obersten Werte vom Stapel und legt ihr Produkt darauf. Die Multiplikationsfunktion kann je nach Forth-System als Maschinencode oder ihrerseits bereits in Forth implementiert sein. Das nächste gelesene Wort ist nun „.“. Dieses Wort nimmt den obersten Wert (nun die Zahl 72) vom Stapel und gibt ihn auf dem Anzeigegerät aus.

=== Beispiel π ===
Die [[Kreiszahl]] Pi kann wie folgt verwendet werden:<ref>{{Internetquelle
|autor=
|url=https://www.forth.com/starting-forth/5-fixed-point-arithmetic/
|titel=Fixed Point Arithmetic
|titelerg=
|werk=
|hrsg=Forth, Inc.
|datum=
|seiten=
|format=
|sprache=EN
|abruf=2025-01-29
|kommentar=
|zitat=
}}</ref>

<code>10340 355 113 */ .</code> → <code>32484</code>

<code>: *Pi 355 113 */ ;</code>

<code>10340 *Pi .</code> → <code>32484</code>

Die [[Kreiszahl#_355113|Näherung]] <code>355÷113</code> hat eine Genauigkeit von 7 Dezimalstellen.

=== Online Forth Interpreter ===
Obige Beispiele können hier<ref>{{Internetquelle
|autor=
|url=https://www.jdoodle.com/execute-forth-online
|titel=Forth Online Editor
|titelerg=
|werk=
|hrsg=JDoodle
|datum=
|seiten=
|format=
|sprache=EN
|abruf=2025-01-29
|kommentar=
|zitat=
}}</ref> interaktiv ausprobiert werden.

=== Wörter für Stack-Operationen ===
{| class="wikitable"
! Befehl
!colspan="3"| Stack
! Beschreibung
|-
| DUP || n1 n2 || → || n1 n2 n2 || dupliziert das oberste Stack-Element
|-
| SWAP || n1 n2 n3 || → || n1 n3 n2 || vertauscht die obersten beiden Stack-Elemente
|-
| ROT || n1 n2 n3 n4 || → || n1 n3 n4 n2 || holt das dritte Stack-Element nach oben
|-
| OVER || n1 n2 n3 || → || n1 n2 n3 n2 || kopiert das zweite Stack-Element
|-
| PICK || n1 n2 n3 ''2'' || → || n1 n2 n3 n1 || kopiert das angegebene ''(hier: 2 entspr. dritte)'' Stack-Element
|-
| DROP || n1 n2 n3 n4 || → || n1 n2 n3 || entfernt das oberste Stack-Element
|}

=== Implementierung und Hardwareschnittstelle ===
{{Siehe auch|Schnittstelle#Hardwareschnittstelle|titel1=Hardwareschnittstelle}}
Beispiel fig-FORTH auf der [[6502]]:<ref name="FIG6502" />

Es werden nur folgende vier Routinen benötigt
{| class="wikitable"
! Name
!colspan="3"| Stack
! Beschreibung
|-
| (KEY) || || → || n1 || liest ein Zeichen von der Tastatur
|-
| (EMIT) || n1 || → || || gibt ein (Steuer-)Zeichen aus
|-
| (?TERMINAL) || || → || n1 || Test, ob eine Taste oder BREAK gedrückt ist
|-
| (CR) || || → || || gibt einen [[Zeilenumbruch]] aus (Carriage Return/Line Feed)
|}

Eine Anbindung an einen [[Massenspeicher]] kann optional eingerichtet werden, entweder zu einem realen, physischen Gerät oder virtuell im Hauptspeicher.

== Anwendungen ==
Forth ist im Gegensatz zu Assembler eine [[Höhere Programmiersprache|Hochsprache]], die trotzdem hardwarenah und damit sehr schnell ausgeführt wird. Die Ausbaufähigkeit ist ein Grundprinzip von Forth; es müssen ohnehin die allermeisten Funktionen selbst programmiert werden. Es existieren mit dem [[RTX2010]] sogar Chipsätze für Raumfahrt-Anwendungen, auf denen Forth direkt ausgeführt werden kann.

Forth eignet sich gut für die interaktive Entwicklung von [[Steuerungssystem]]en, wobei das Ergebnis der Lesbarkeit von [[Pseudocode]] nahekommen kann:

# Ventil öffnen
# Alarm einschalten
# Türen verriegeln
# usw.

Die frühesten bekannten Anwendungen waren Steuerungen für Radioteleskope und [[Sternwarte|Observatorien]] für [[Astronomie]] und [[Raumfahrt]]. Andere Anwendungen im technisch-wissenschaftlichen Bereich kamen erst später hinzu. Mit einem Einsatz auf der Raumsonde [[Galileo (Raumsonde)|Galileo]] war Forth 1989 eine der ersten Hochsprachen im Weltraum, bis dahin waren für solche Systeme überwiegend Assembler-Sprachen üblich.<ref>[https://history.nasa.gov/computers/Ch6-3.html ''Computers in Spaceflight: The NASA Experience – Chapter Six: Distributed Computing on Board Voyager and Galileo'']. history.nasa.gov, abgerufen am 23. August 2019.</ref><ref>[https://www.forth.com/resources/space-applications/ ''Forth in Space Applications'']. FORTH, Inc., abgerufen am 23. August 2019.</ref> Auch die Raumsonde [[Philae (Sonde)|Philae]], bekannt durch die Landung auf einem Kometen 2014, war in Forth programmiert.

== Forth-Implementierungen und abgeleitete Sprachen ==
Die Portierung von Forth auf den [[Apple II]] führte in den 1970er Jahren der Programmierer [[John T. Draper]] durch, damit entwickelte er die Textverarbeitung [[EasyWriter]]. Eine grafikfähige Erweiterung von Forth für den Apple II war GraFORTH.<ref>[https://www.virtualapple.org/docs/GraFORTH%20II%20Language%20Reference.pdf GraFORTH II Language Reference (PDF; 4,5 MB)]{{Toter Link|url=https://www.virtualapple.org/docs/GraFORTH%20II%20Language%20Reference.pdf |date=2022-11 |archivebot=2022-11-02 05:58:40 InternetArchiveBot }}</ref> ASYST war eine Erweiterung von Forth zum [[Messung|Messen]], [[Steuerungstechnik|Steuern]] und [[Regelungstechnik|Regeln]] für [[Personal Computer|PCs]].<ref>Campbell et al., „Up and Running with Asyst 2.0“, MacMillan Software Co., 1987</ref>

[[Factor]] ist eine auf Forth aufbauende Programmiersprache, die sich jedoch stärker an die [[Anwendungsentwicklung]] orientiert als an der maschinennahen Funktionalität von Forth. Eine neuere Anwendung für Forth ist das Konzept der [[Open Firmware]] (IEEE-1275).

Eine Weiterentwicklung von Forth ist [[Interpress]] von [[Xerox]], woraus sich wiederum die Seitenbeschreibungssprache [[Adobe Inc.|Adobe]] [[PostScript]] entwickelte. Das später ebenfalls von Adobe entwickelte [[Portable Document Format|PDF]] lehnt sich zwar stark an PostScript an (und könnte somit als Urenkel von Forth angesehen werden), ist jedoch im Gegensatz zu PostScript und Forth keine vollständige Programmiersprache.

* [https://thebeez.home.xs4all.nl/4tH/ 4tH] Implementierung von Hans Bezemer, multiplattform
* [http://amforth.sourceforge.net/ amforth] – für den Atmel-ATMega-Mikrocontroller (GPL)
* [http://www.kiblerelectronics.com/myf/myf.shtml myforth für 8051 chips] – Tethered Forth
* [https://github.com/CharleyShattuck/myforth-arduino myforth für arduino]
* ''C-128-Forth'' – 1986 vom westdeutschen Holtkötter-Verlag veröffentlichter Forth-Dialekt für den 8-Bit-Heimcomputer [[Commodore 128#Forth|Commodore 128]]<ref>Manfred Wenzel: ''Forth am Commodore 128.'' In: ''Commodore Welt.'' Band 3, Nr. 11 (1986), S. 56 f.</ref>
* [https://github.com/meshula/Fusion-Forth Fusion-Forth für den Atari ST]
* [https://github.com/mynenik/kForth-32 kForth-32] – kleiner Forth-Interpreter, in C++ geschrieben (x86, 32-Bit)
* [https://code.google.com/archive/p/propforth/wikis/PropForth.wiki PropForth] – für den Parallax-Propeller-Mikrocontroller
* [[Reverse Polish LISP]] (RPL) – für HP48/49-Taschenrechner
* [http://sametwice.com/herkforth herkforth] – ein colorForth für Linux/PPC
* [http://home.hccnet.nl/a.w.m.van.der.horst/ciforth.html Computer Intelligence Forth] – ein in Assembler geschriebenes ISO-Forth
* [http://pfe.sourceforge.net/ PFE] – Portable Forth Environment
* [https://www.macupdate.com/app/mac/11376/imops Mops] – eine Entwicklungsumgebung für den Apple-Macintosh, basierend auf Forth
* [http://dev.ronware.org/p/reva/home Reva] – für x86-Prozessoren (32 Bit, multiplattformfähig)
* [http://spf.sourceforge.net/ SP-Forth] – OpenSource Forth für Win32 u. Linux
* [[STOIC (Programmiersprache)|STOIC]] – von [[Jonathan Sachs]] für [[Minirechner]] entwickelt und später auf [[CP/M]] portiert.
* [http://volksforth.sourceforge.net/ volksFORTH] – ein System der Forth Gesellschaft e. V.
* [http://win32forth.sourceforge.net/ Win32Forth] – Public Domain/[[GNU Lesser General Public License|LGPL]], für Windows (32 Bit)
* [https://github.com/shanecelis/delta-forth-net Delta Forth .NET] – Forth Compiler für die .NET-Plattform
* [https://www.forth.com/ SwiftFORTH und SwiftX] – professionelles FORTH für PC und Mikrocontroller
* [http://home.iae.nl/users/mhx/i4faq.html iForth] – Shareware, multiplattformfähiger Compiler für 32 u. 64 Bit
* [https://www.inventio.co.uk/cfdos.htm colorForth] – für den PC, Floppy-Image-Extracter/Source-Reader
* [https://bernd-paysan.de/bigforth.html bigFORTH] – x86 native code Forth mit MINOS GUI
* [https://bernd-paysan.de/gforth.html Gforth] – GNU Forth, multiplattformfähiger Interpreter (32 und 64 Bit)
* [https://www.mpeforth.com/ VFX Forth] – professioneller, plattformübergreifender Forth Compiler
* [http://retroforth.org/ RetroForth] – für DOS, Linux, FreeBSD, Windows oder standalone
* [http://www.softsynth.com/pforth/ pForth] – PD portables Forth in 'C' für eingebettete Systeme oder Desktops
* [https://github.com/jkotlinski/durexforth DurexForth] – modernes OpenSource Forth für den [[Commodore 64|C64]]; ein Diskettenimage der jeweils aktuellen Version bekommt man [https://github.com/jkotlinski/durexforth/releases/latest hier.]
* [http://aminet.net/package/dev/lang/J4thDemo JForth] – Demo für Amiga
* fig-FORTH<ref name="FIG6502">
{{Internetquelle
|autor=William F. Ragsdale
|url=https://web.archive.org/web/20221113014633if_/http://archive.6502.org/books/forth_interest_group/fig_forth_installation.pdf
|titel=fig-FORTH INSTALLATION MANUAL
|titelerg=(Implementation auf 6502)
|werk=
|hrsg=FORTH INTEREST GROUP
|datum=1980-11
|seiten=66
|format=PDF
|sprache=EN
|abruf=2025-01-21
}}</ref>

== Siehe auch ==
* [[Jupiter Ace]]
* [[Canon Cat]]

== Literatur ==
* Leo Brodie: ''Starting FORTH'', 1981 ([https://www.forth.com/starting-forth/ aktualisierte Online-Edition])
* Leo Brodie: ''Thinking FORTH'', Punchy Publishing, 2004, ISBN 978-0-9764587-0-8.
* Ronald Zech: ''Die Programmiersprache FORTH : eine kompakte Darstellung der Programmiersprache mit vielen Beispielen'', 2. Auflage, Franzis, 1985, ISBN 3-7723-7262-7
* Thom Hogan: ''FORTH – Ganz einfach'', übers. v. Karl-Heinz Büchner, Vieweg & Sohn, Braunschweig/Wiesbaden, 1985, ISBN 978-3-528-04292-9.
* C. Kevin McCabe: ''Programmieren mit FORTH'', übers. v. Peter Monadjemi, Springer Vieweg, 1988, ISBN 978-3-322-90106-4.
* Edward K. Conklin, Elizabeth D. Rather: ''Forth Programmer's Handbook'', Forth Inc., 1997, ISBN 0-9662156-0-5.
* Elizabeth D. Rather: ''Forth Application Techniques'', 5. Auflage, Forth Inc., Los Angeles, 2008, ISBN 1-4196-8576-7.
* Mitch Derick, Linda Baker: ''FORTH Encyclopedia – The Complete Forth Programmer's Manual'', 2. Ausg., Mountain View Press, Mountain View CA, USA, 1982, ISBN 978-99931-65-63-7.
* W. P. Salman, O. Tisserand, B. Toulout: ''FORTH'', Editions EYROLLES, Paris 1983, engl. Übersetzung von M.J. Stewart, Macmillan Publishers Ltd. 1984, ISBN 978-0-333-36798-8.

== Weblinks ==
* [https://www.forth-ev.de/ Forth-Gesellschaft e. V. (Deutschland)]
* [http://www.ultratechnology.com/4th_1970.html FORTH – A Language for Interactive Computing], Charles H. Moores früheste Veröffentlichung zur Sprache (1970)
* [http://thinking-forth.sourceforge.net/ Thinking Forth Project]
* [https://www.zock.com/64er/8407/0011.html Forth – die etwas andere Programmiersprache], [[64’er]]-Bericht (1984)
* [https://hackerfunk.ch/index.php?id=66 Forth – Audiocast bei Hackerfunk.ch, Zürich]
* [https://www.complang.tuwien.ac.at/forth/family-tree/ Forth Family Tree]

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4017981-3|LCCN=sh85050918}}

[[Kategorie:Forth (Programmiersprache)| ]]
[[Kategorie:Konkatenative Programmiersprache]]
[[Kategorie:Programmiersprache mit einem ISO-Standard]]
[[Kategorie:Programmiersprache]]
[[Kategorie:Virtuelle Maschine]]

Forth (Programmiersprache) - Versionsgeschichte

imported>Sotel: /* Beamtendeutsch ersetzt */