Minirechner/Rechner für FORTH

funkheld schrieb:
> Wo gibt es bitte ein fertigen Minirechner/Rechner für FORTH zum
> Basteln/Spielen im Hobbybereich?

Antiquarisch:

Jupiter ACE.

Ohne Speichererweiterung allerdings nur recht eingeschränkt verwendbar, 
da weniger als 1 kB freies RAM verfügbar.

funkheld schrieb:
> Wo gibt es bitte ein fertigen Minirechner/Rechner für FORTH zum
> Basteln/Spielen im Hobbybereich?
>
> Ich finde leider nichts derartiges.

http://www.pc-1500.info/wp-content/uploads/2014/08/PC-SOFTWARE.pdf
Seite 10

PC 1500 findet man noch gebraucht, ob man PC Forth noch findet? keine 
Ahnung

Schau Dir mal ItsyForth an und den Artikel 'Moving forth'. Hab ich bei 
reddit gefunden.

Dieter schrieb:
> Meine Empfehlung ist jedoch ein Board mit mindestens 1GB RAM (besser 2GB
> RAM) zu verwenden mit mindestens einem Quadcorte als Prozessor, wenn es
> umfangreiche Forth-Programme sein sollen.

Der von mir erwähnte Jupiter ACE war ein reinrassiges Single-Core-System 
mit 3.5 MHz Taktfrequenz und insgesamt 3 kiB RAM, von dem ganze 956 
Bytes für eigene Programme zur Verfügung standen. Das Forth selbst war 
in zwei EPROMs à 4 kiB untergebracht.

Das Ding kann man übrigens nachbauen, hier http://www.jupiter-ace.co.uk/ 
gibt es auch diverse weitere Informationen, unter anderem auch ein 
kommentiertes Disassemblat der Firmware:

http://www.jupiter-ace.co.uk/romlisting.html

Wir basteln gerade an fpga Kram und ich schau mir auch gerade forth wg 
einer potentiellen Portierung an, aber vermutlich ist das für den 
Threadstarter doch zuviel gebastelt. Denke ich zumindest mal.

Wer die Forth-Denkweise mag, kann auch mit seinem Drucker glücklich 
werden - Forth und PostScript sind schon irgendwie verwandt: 
http://wiki.c2.com/?ForthPostscriptRelationship

bla schrieb:
> Blöde Frage, aber für was sollte man heute noch FORTH lernen? Sieht
> ziiiemlich antiquiert aus.

Aus dem selben Grund aus dem Leute heutzutage noch Lisp lernen, eine 
zeitlose minimalistische Eleganz. Während jene Eleganz bei Lisp die 
Sprache selbst ist, so ist sie bei Forth dessen "effizienter" Umgang mit 
der Hardware.

In Anführungszeichen deshalb weil Forth Code gegen generiertes 
hochoptimiertes Assembly ziemlich schlecht abschneidet.

Hallo, ich habe nicht ganz verstanden, ob du erst mal Forth etwas lernen 
möchtest oder ob du Controller suchst, die Forth "draufhaben" und du 
dann loslegen willst. Fürs Lernen ist ganz sicher ein Forth, das auf 
einem PC läuft, die erste Wahl. Da kann man sich austoben und lernen! 
Forth für einen Controller (z.B. Amforth) mußt du entweder finden oder 
selbst portieren, was dann schon sehr ins Eingemachte geht! Wie auch 
immer, schöne Feiertage...
Gruß Rainer

Vincent H. schrieb:
> Aus dem selben Grund aus dem Leute heutzutage noch Lisp lernen, eine
> zeitlose minimalistische Eleganz.

Naja, eigentlich ist der Grund ein Anderer.
Kaum eine Sprache beherscht so perfekt das "data as code" wie Lisp.

Da das aber komplett off-topic ist:

Paul Graham "On lisp" (fliegt auch im WEB rum),
Doug Hoyte  "Let over Lambda" (vermutlich nur kaufbar)

Es hilft etwas die Beiden auch in dieser Reihenfolge zu lesen, denn die 
dahinterstehende Idee ist einem in der Theorie schnell klar.
Aber bis man es wirklich umsetzen kann ...

/regards

Arduino Fanboy D. schrieb:
> Man muss es mögen, oder man verzweifelt daran.

Fibonacci-Zahlen in vier Zeilen? Für Forth-Experten ist das beleidigend 
ausschweifend:

1

: fib

2

  DUP 1 > IF 

3

  1- DUP 1- RECURSE SWAP RECURSE + THEN

4

;

Markus F. schrieb:
> Fibonacci-Zahlen in vier Zeilen? Für Forth-Experten ist das beleidigend
> ausschweifend:

Na das ist schon etwas geschummelt; Auch wenn bei UPN, Befehle 
hintereinander geschrieben noch lesbar sind, ist das nicht zwingend eine 
Zeile. Abei ein kompletter 8080 Simulator in C (auch nur eine Zeile) ;

for(v A((u A((e A((r-2?0:(V A(1[U])),"C")
),system("stty raw -echo min 0"),fread(l,78114,1,e),B(e),"B")),"A")); 
118-(x
=*c++); (y=x/8%8,z=(x&199)-4 S 1 S 1 S 186 S 2 S 2 S 3 S 
0,r=(y>5)*2+y,z=(x&
207)-1 S 2 S 6 S 2 S 182 S 4)?D(0)D(1)D(2)D(3)D(4)D(5)D(6)D(7)(z=x-2 C C 
C C
C C C C+129 S 6 S 4 S 6 S 8 S 8 S 6 S 2 S 2 S 12)?x/64-1?((0 O a(y)=a(x) 
O 9
[o]=a(5),8[o]=a(4) O 237==*c++?((int 
(*)())(2-*c++?fwrite:fread))(l+*k+1[k]*
256,128,1,(fseek(y=5[k]-1?u:v,((3[k]|4[k]<<8)<<7|2[k])<<7,Q=0),y)):0 O 
y=a(5
),z=a(4),a(5)=a(3),a(4)=a(2),a(3)=y,a(2)=z O c=l+d(5) O 
y=l[x=d(9)],z=l[++x]
,x[l]=a(4),l[--x]=a(5),a(5)=y,a(4)=z O 
2-*c?Z||read(0,&Z,1),1&*c++?Q=Z,Z=0:(
Q=!!Z):(c++,Q=r=V?fgetc(V):-1,s=s&~1|r<0) O++c,write(1,&7[o],1) O 
z=c+2-l,w,
c=l+q O p,c=l+z O c=l+q O s^=1 O Q=q[l] O s|=1 O q[l]=Q O Q=~Q O 
a(5)=l[x=q]
,a(4)=l[++x] O 
s|=s&16|9<Q%16?Q+=6,16:0,z=s|=1&s|Q>159?Q+=96,1:0,y=Q,h(s<<8)
O l[x=q]=a(5),l[++x]=a(4) O x=Q%2,Q=Q/2+s%2*128,s=s&~1|x O Q=l[d(3)]O 
x=Q  /
128,Q=Q*2+s%2,s=s&~1|x O l[d(3)]=Q O s=s&~1|1&Q,Q=Q/2|Q<<7 O Q=l[d(1)]O 
s=~1
&s|Q>>7,Q=Q*2|Q>>7 O l[d(1)]=Q O m y n(0,-,7)y) O m z=0,y=Q|=x,h(y) O m 
z=0,
y=Q^=x,h(y) O m z=Q*2|2*x,y=Q&=x,h(y) O m Q n(s%2,-,7)y) O m Q 
n(0,-,7)y)  O
m Q n(s%2,+,7)y) O m Q n(0,+,7)y) O z=r-8?d(r+1):s|Q<<8,w O 
p,r-8?o[r+1]=z,r
[o]=z>>8:(s=~40&z|2,Q=z>>8) O r[o]--||--o[r-1]O 
a(5)=z=a(5)+r[o],a(4)=z=a(4)
+o[r-1]+z/256,s=~1&s|z>>8 O ++o[r+1]||r[o]++O o[r+1]=*c++,r[o]=*c++O 
z=c-l,w
,c=y*8+l O x=q,b z=c-l,w,c=l+x) O x=q,b c=l+x) O b p,c=l+z) O a(y)=*c++O 
r=y
,x=0,a(r)n(1,-,y)s<<8) O r=y,x=0,a(r)n(1,+,y)s<<8))));
system("stty cooked echo"); B((B((V?B(V):0,u)),v)); }

Arduino Fanboy D. schrieb:
> Wieso hast du Probleme bei der Auswahl?
> Welche?

Er möchte halt spielen und nicht Implementieren! Und wenn er nicht am PC 
Spielen möchte, dann bleibt ja nur sowas wie ein Raspi mit einem Forth, 
das unter Linux läuft...da muß man halt mal etwas suchen. Ein 
bare-metal-Forth auf dem Raspi ist auch denkbar, aber da muß einiges an 
Arbeit rein, bis das ersehnte "OK" auf dem "bescheidenen" Display 
erscheint!
Ich beantworte also die Frage des TO mit einem klaren Nein.
Gruß Rainer

Wie wäre es denn mit einem alten SPARC-basierten Rechner von Sun? Darauf 
befindet sich ein recht umfangreiches Programm namens Open Firmware bzw. 
OpenBootRom, welches eine FORTH-Umgebung bereitstellt. Neulich wollte 
hier im Forum doch einer eine alte Sun E250 verschenken.

Arduino Fanboy D. schrieb:
> Sucht man ein Board auf dem man mit winzigem Aufwand Forth zum laufen
> bekommt, dann

Der winzige Aufwand ist aber bei genauer Betrachtung vielleicht doch 
nicht sooo winzig. Möglicherweise fragt der TO ja gerade deshalb.
Auch auf den Atari's lief ein gutes Forth, das einfach von Diskette 
geladen wurde. Aber weder ein älterer Sun-, noch ein Atari-Rechner wird 
dem TO helfen können...denn sonst würde er ja doch direkt mit seinem PC 
spielen.
Und sogar auf den diversen Atari-Emulationen unter Windof konnte man das 
Forth laufen lassen!
Gruß Rainer

Genau für einen solchen Wunsch steht seit kurzem der wunderschöne Entwurf von Dennis Kuschel zur Verfügung, den er auf www.mynor.org dokumentiert hat. Ein sehr vollständiger, aber einfach zu montierender Einplatinencomputer (auf einer Leiterplatte von nur 100 x 100 mm) mit etwa 16 Standard-ICs der 74xx-Serie und einigen Speicherchips. Lediglich das EPROM (ein 27C256 oder ein W27C512) muss programmiert werden. Das Design dieser Schaltung ist kreativ, da sie keinen Prozessor, ALU, PLDs oder andere Intelligenz enthält. Das Herzstück des My4TH-Computers ist ein einzelnes NOR-Gatter in einem 74HC02. Es verfügt über RS232- und I2C-Schnittstellen an Bord sowie eine Reihe frei nutzbarer digitaler Ein- und Ausgänge. Und die komplett online verfügbare Dokumentation rundet das Ganze ab.

Ich habe die My4TH-Schaltung selbst gebaut und es hat auf Anhieb funktioniert. Da ich mehr Komponenten gekauft habe, als ich für meinen benötigt habe, biete ich einige Bausätze bei eBay an. Zusätzlich zu diesen Bausätzen kann ich diese auf Wunsch auch fertig montiert und getestet verschicken (bitte hier zurückmelden). Die gebrauchsfertigen kosten EUR. 260, = pro Stück + Versandkosten.

Ein Demonstrationsvideo kann hier angesehen werden: https://www.youtube.com/watch?v=inFINndk10o.

eprive

Was soll diese Werbung in einem ueber 4 Jahre totem Thread?

Möchten Sie es lieber in einem neuen Thread ?

Das My4TH is vor einigen Monaten in 2023. Und vor allem interessant für Forth Liebhaber.

Mecrisp Stellaris Forth: Kostenlos Raspberry Pi Pico: €4,10 Fertich…

ESP32 oder RP2040 wäre meine Wahl mit Forth! Alle Projekte sind aktiv, interessant und praktisch verwendbar.

https://esp32.arduino-forth.com/ https://esp32forth.forth2020.org/home https://esp32forth.appspot.com/ESP32forth.html https://github.com/MitchBradley/cforth

Willem P. schrieb:

Möchten Sie es lieber in einem neuen Thread ?

Der Post gehört in die Rubrik Markt.

Hier beschäftigen sich Leute auch mit dem kleinen Rechner:

https://forum.classic-computing.de/forum/index.php?thread/30032-my4th-mini-forth-system-ohne-cpu/&postID=418467#post418467

FORTHza gugel schrieb:

FIGForth auf "allem was auf 2 nicht auf Bäume war"

• < http://www.forth.org/fig-forth/contents.html >

...und google findet noch viel mehr!

Eine nette Übersicht zu Fig-Forth gibt es bei https://www.jimbrooks.org/archive/programming/forth/FIG-FORTH_internals.php

Forth zu implementieren kann auch ziemlich spaßig sein -- sofern man noch einen Prozessor findet, auf dem das noch nicht längst geschehen ist...

Beispiele für Portierungen gibt es unter https://forth-standard.org/systems oder auch unter http://www.forth.org/fig-forth/contents.html.

Oft ist der (Fig-)Forth-Interpreter selbst in Forth geschrieben - bis auf einen Winzig-Teil, den Inneren Interpreter, vgl. https://wiki.forth-ev.de/doku.php/words:axiome:inner_interpreter. Und das können oft nur wenige Zeilen Assembler sein ...

Wer es noch wilder treiben will, schaue sich mal Forth-Core -- also spezielle Forth-Hardware -- an, z.B. http://forth.org/cores.html

Dabei ist Forth kein "Alter Käse". FreeBSD benutze es vor V 13.0 als Skriptsprache im Bootloader, und Heise online titelte noch in 2020

"Forth – die ewig junge Programmiersprache"

(https://www.heise.de/hintergrund/Forth-die-ewig-junge-Programmiersprache-4988866.html)

Ich mag Forth trotz RPN -- aber ich mag auch meinen ollen hp-32 ...

Weiß nicht ob's heutzutage noch so ist, aber Forth war mal DIE Programmiersprache der Astronomen zur Steuerung ihrer Teleskope.

Ich glaub, es gibt auch paar Mainboards, wo das BIOS in Forth geschrieben ist? Und Postscript basiert doch auch auf Forth?

Ich find es ne coole Sprache, um zum ersten Mal einen Interpreter zu implementieren.

Vor über 14 Jahren machten wir in der Firma eine Test SW mit einem in C geschriebenen 32-bit Forth auf einem ARM7 CPU laufend. Das lief auf einer Embedded Artist NXP LPC3468 Development Board. Hatte auch ein 320x240 TFT Display dran über einen Epson Graphic Controller mit Frame Buffer betrieben. War superschnell und man konnte das Forth-Dictonary leicht in C im Source Code erweitern. Vom Terminal aus funktionierte das Teil wie ein HP Calculator in RPN. Man konnte es also auch als Calculator mitverwenden. War eigentlich ein nettes Spielzeug. Es war echt atemberaubend, was ein paar "einfache" Keywords eingetippt, mit der HW zustande brachten. Ich hatte aber nichts mit dem Programmieren zu tun, das machte ein Kollege. Er instruierte mich aber wie man neue Keyword Funktionen schreiben konnte.

Die SW wurde mit einem IAR IDE System gebaut.

Als interaktives, BS-artiges Werkzeug, war die Forth SW definitiv sehr beeindruckend.

Ich finde Forth für gewisse Anwendungen prinzipiell recht nützlich. Speziell wenn man von einem Kommando Terminal aus agiert.

Ich habe übrigens noch einen HP71B mit FORTH ROM.

Andreas R. schrieb:

Ich glaub, es gibt auch paar Mainboards, wo das BIOS in Forth geschrieben ist?

https://en.wikipedia.org/wiki/Open_Firmware

War superschnell und man konnte das Forth-Dictonary leicht in C im Source Code erweitern.

Natuerlich, Forth ist auch noch etwas naeher an Assembler als C. Das Problem ist nur sobald du etwas programmierst das groesser ist wie drei DinA4 Seiten verstehst du nicht mehr was du da selber gemacht hast.

Vanye

Vanye R. schrieb:

Natuerlich, Forth ist auch noch etwas naeher an Assembler als C. Das Problem ist nur sobald du etwas programmierst das groesser ist wie drei DinA4 Seiten verstehst du nicht mehr was du da selber gemacht hast.

Forth wurde schon früh als "Write-only Language" bezeichnet.

Die Wikipedia schreibt hierzu:

"In computer humor, a write-only language is a pejorative term for a programming language alleged to have syntax or semantics sufficiently dense and bizarre that any routine of significant size is too difficult to understand by other programmers and cannot be safely edited.

Languages that have been derided as write-only include APL, C/C++, Perl, Forth, Scala and Lisp ..."

So gesehen befindet sich Forth in nicht ganz schlechter Gesellschaft...

Woran Forth imho "leidet" ist, dass sich keiner mit RPN (Reverse Polish Notation) beschäftigen will. Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard. Aber ich wiederhole mich...

Joe L. schrieb:

Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard.

Das ist wohl ein Verdrahtungsding. Der Taschenrechner, mit dem man zuerst konfrontiert wird, der prägt einen, und die Logik brennt sich ins Hirn ein. Das später zu ändern ist mühsam, schwer bis unmöglich.

Du dürftest eigentlich prädestiniert dafür sein, Postscript von Hand zu schreiben, das ist nämlich auch eine stackorientierte Programmiersprache.

Vor vier Jahren wurde hier schon der Exot unter den erfolglosen Homecomputern erwähnt, der "Jupiter Ace" von 1982. Der hatte einen Forth-Interpreter im (8k großen) ROM und war technisch dem Zeitgenossen ZX 81 deutlich überlegen (mehr RAM, dedizierte Hardware für die Bildschirmansteuerung, bessere Tastatur), scheiterte aber an der auch damals schon ... sehr exotischen Programmiersprache.

Auf dem Apple II gab es damals mit GraForth eine Forth-Variante, bei der der Schwerpunkt auf Graphikerzeugung gelegt wurde. Auch die kennt vermutlich niemand mehr.

--

Oh, es gibt ein Handbuch!

https://mirrors.apple2.org.za/ftp.apple.asimov.net/documentation/programming/forth/GraFORTH%20Manual%20-%20inSoft.pdf

Gerade mal ins Bücherregal gegriffen. 1980 war ich in Mountain View bei der figFORTH group. Die Adresse war ein Wohnwagen neben dem Bahndamm. Auf Grund des "Freedom Of Information Act" konnte ich die Adresse hinter dem Postfach beim Postal Office erfragen.

Der Typ - ich weiß den Namen nicht mehr - hat mir dann nette Anekdoten erzählt, wie er einmal mit Charles Moore im Auto fuhr und Charles ihm dann von einer Programmiersprache FORTH vorgeschwärmt hatte, die er entwickelt hatte.

too difficult to understand by other programmers and cannot be safely edited.

Naja, other Programmers waer ja noch okay, aber das folgende Programm habe ich mal als aufstrebender Student selber geschrieben und verstehe selber nicht mehr. :)

1

@ Program zur cubischen Spline Interpolation von Daten oder Messwerten

2

@                       Version 1.0  3/92  

3

@ Das Programm erwartet beim Aufruf der Procedure INIT die Daten in einem

4

@ zweidimensionalen Feld  SDAT (Summenzeichen) wie es von den Integrierten

5

@ Statistikprogrammen angelegt wird.

6

@ Zu Beginn muss einmal die Procedure INIT aufgerufen werden um die 

7

@ Stuetzstellen zu berechnen.

8

@ Die Function SPLINE erwartet beim Aufruf den Punkt fuer den 

9

@ Interpoliert werden soll in der Variablen X und liefert das Ergebnis

10

@ auf den Stack zurueck. Mit den Befehlen des eingebauten Plot Menues

11

@ kann die Funktion sofort gezeichnet werden.

12

DIR

13

14

  SPLINE

15

    \<<

16

       1    's' STO

17

       N\GS 'r' STO

18

       WHILE r s - 1 > REPEAT

19

         r s + 2 / IP

20

         DUP

21

         IF '\GSDAT' SWAP 2 * 1 - GET X > THEN 'r' STO

22

                                          ELSE 's' STO

23

        END

24

       END

25

       'h' s 1 + GET 'k' STO

26

       '\GSDAT' s 1 + 2 * GET '\GSDAT' s 2 * GET - k /

27

       'M' s GET 2 * 'M' s 1 + GET + k * 6 / 

28

       - 'a' STO

29

       'M' s 1 + GET 'M' s GET - k 6 * / 'b' STO

30

       X  '\GSDAT' s 2 * 1 - GET - DUP a * SWAP DUP SQ 2 / 'M' s GET * SWAP

31

       4 ^ b * + + '\GSDAT' s 2 * GET +       

32

    \>>

33

34

  INIT

35

    \<<

36

       0 1 N\GS 2 + FOR j DUP NEXT N\GS 2 + \->ARRY SWAP DROP 

37

       DUP 'M' STO 

38

       DUP 'h' STO

39

       DUP 'b' STO

40

       DUP 'v' STO

41

       DUP 'd' STO

42

           'q' STO

43

       '\GSDAT' 3 GET '\GSDAT' 1 GET - 'h' 2 ROT PUT

44

      2 N\GS 1 - FOR j

45

          j 1 + 'sj' STO

46

          '\GSDAT' sj 2 * 1 - GET '\GSDAT' j 2 * 1 - GET - 'h' sj ROT PUT

47

          'h' sj GET DUP 'h' j GET + / DUP 'b' j ROT PUT

48

          1 SWAP - 'v' j ROT PUT

49

          '\GSDAT' sj 2 * GET '\GSDAT' j      2 * GET - 'h' sj GET /

50

          '\GSDAT' j  2 * GET '\GSDAT' j  1 - 2 * GET - 'h'  j GET /

51

          - 6 * 'h' j GET 'h' sj GET + / 'd' j ROT PUT

52

       NEXT

53

       'q' 2 2 PUT

54

       2 N\GS 2 - FOR j

55

          j 1 + 'sj' STO

56

          2 'b' j GET 'v' sj GET * 'q' j GET / - 'q' sj ROT PUT

57

          'd' sj GET 'd' j GET 'v' sj GET * 'q' j GET / - 'd' sj ROT PUT

58

       NEXT

59

       N\GS 1 - DUP 'd' SWAP GET SWAP DUP 'q' SWAP GET ROT SWAP / 'M'

60

       ROT ROT PUT 

61

       N\GS 2 - 2 FOR j

62

       'd' j GET 'b' j GET 'M' j 1 + GET * - 'q' j GET / 'M' j ROT PUT

63

       -1 STEP  

64

       0 0 0 0 'b' STO 'd' STO 'v' STO 'q' STO

65

    \>>

66

67

  X 2

68

69

  EQ 

70

  { SPLINE }

71

  PPAR

72

  { (0,0) (20,40) X 0 (0,0) FUNCTION Y }

73

74

  sj 0

75

  v

76

[ 1 ]

77

  d

78

[ 1 ]

79

  q

80

[ 1 ]

81

  b

82

[ 1 ]

83

  k 0

84

  hs 0

85

  h

86

[ 6 ]

87

  M

88

[ 1 2 ]

89

  n 0

90

  r 0

91

  s 0

92

  a 0

93

END

Na? Seht ihr das ueberlegende Konzept dieser Programmiersprache? Ist doch praktisch selbsterklaerend. Und da hat der Nachwuchs heute Probleme mit der systemimanenten Eleganz von C und fluechtet in Python? :-D

Vanye

Da erkenne ich momentan nicht gerade FORTH.

Harald K. schrieb:

Joe L. schrieb:

Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard.

Das ist wohl ein Verdrahtungsding. Der Taschenrechner, mit dem man zuerst konfrontiert wird, der prägt einen, und die Logik brennt sich ins Hirn ein. Das später zu ändern ist mühsam, schwer bis unmöglich

Liest man ab und zu. Z.B. (*) aber argumentiert aber in eine andere Richtung.

Tatsächlich musste auch ich mich lange mit "Normalen"/AN-Taschenrechnern rumärgern: Ein hp-35 (1972: ~2000DM) war monitär nicht drin, erst einen hp-25 konnte ich mir von meinem mageren Lehrlings-Lohn (ca. 1977: ~300DM) leisten.

Meinem alten Herrn hatte ich später (als er sich in seinen 50'ern mit Astro-Navigation beschäftigt hatte) einen hp-32S aufgeschwatzt. Obwohl vorher nie mit RPN konfrontiert, kam er innerhalb von wenigen Tagen damit klar.

(*) https://vdocuments.mx/electronic-calculators-which-notation-is-the-better.html

Da erkenne ich momentan nicht gerade FORTH.

Ist das Forth des HP48.

Vanye

Vanye R. schrieb:

Ist das Forth des HP48.

OK, das machts nicht leichter zu lesen....

Mir scheinen die Worte zu lang zu sein. (zuviel Code pro Wort) Lieber mehr Worte erfinden, als lange Worte. Dann fehlt jeglicher Stackkommentar.

Ja, man kann in Forth schwer lesbare Programme schreiben. Und DAS ist ein gutes Beispiel dafür, wie man es nicht tun sollte.

Joe L. schrieb:

Liest man ab und zu. Z.B. (*) aber argumentiert aber in eine andere Richtung.

Vor meinem Erstkontakt mit Forth habe ich ein wenig mit Basic herumgefrickelt, Forth konnte mich nicht überzeugen, auch schon damals (auf dem Apple II) nicht. Dann kam etwas Pascal, mit dem ich lernte, daß es eine zum Lernen gut geeignete, zum Anwenden weniger gut geeignete Sprache ist (alleine die merkwürdigen Verknotungen, die man anstellen musste, um irgendwas mit Dateien machen zu können, damals, lange vor Turbo-Pascal unter DOS), und dann nutzte ich eine ganze Zeit lang Assembler. Ein bisschen auf Z80, LH5801, mehr auf 6502 und deutlich mehr auf 6809.

Programmierbare Taschenrechner haben mich noch nie gereizt, der LH5801-Ausflug war nicht für mich selbst, sondern damit unterstützte ich jemand anderes.

Nee, Forth mag Ende der 70er, Anfang der 80er in Ermangelung schicker Alternativen reizvoll gewesen sein, oder wenn man eben viel mit HP-Taschenrechnern zu tun hatte, aber sonst?

Mag sicher eine lustige Gehirnübung sein, so etwas wie das von Vanye zitierte Zeug zu schreiben ... oder gar zu verstehen, aber ... nee, nicht mit mir.

Joe L. schrieb:

Forth wurde schon früh als "Write-only Language" bezeichnet.

Woran Forth imho "leidet" ist, dass sich keiner mit RPN (Reverse Polish Notation) beschäftigen will. Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard.

Bei klassischen Taschenrechnern sind die eingegebenen Terme naturgemäß write-only, angezeigt wird lediglich das Rechenergebnis und vorher ggf. noch ein paar Zwischenergebnisse. Da mit RPN die einzelnen Zahlenwerte und Rechenoperationen genau in derselben Reihenfolge eingegeben werden, wie wir sie auch beim Kopfrechnen verarbeiten würden, ist dies die mit Abstand natürlichste aller möglichen Eingabemethoden.

Ganz anders sieht es bei der Programmierung aus: Da wird der Quellcode sehr viel öfter gelesen als geschrieben. Das Auge erfasst Programmtext leichter, wenn er geeignet strukturiert ist. So ist bspw. in folgendem Ausdruck in Infix-Notation sofort erkennbar, dass es sich um ein Produkt aus zwei Summen handelt:

1

(1 + 2) * (3 + 4)

In Postfixnotation ist zwar ebenfalls leicht erkennbar, dass es sich um ein Produkt handelt (der letzte Operator ist ein "*"), aber die weitere Analyse des Terms gestaltet sich deutlich schwieriger.

1

1 2 + 3 4 + *

Ähnlich wie die Eingabe bei RPN-Taschenrechnern geht auch das Schreiben von Forth-Programmen nach kurzer Einarbeitung recht leicht von der Hand. Schaut man sich den Code aber ein Jahr später noch einmal an, dauert es eine ganze Weile, bis man sich wieder darin zurechtfindet.

Das krasse Gegenteil von Forth ist Haskell. Dort ist es mitunter etwas knifflig, eine Idee in Code umzusetzen, dafür ist es umso leichter, diesen Code nach einem Jahr noch zu verstehen.

Harald K. schrieb:

Das ist wohl ein Verdrahtungsding. Der Taschenrechner, mit dem man zuerst konfrontiert wird, der prägt einen, und die Logik brennt sich ins Hirn ein. Das später zu ändern ist mühsam, schwer bis unmöglich.

Das kann ich nicht bestätigen. Mir geht/ging es ähnlich wie Joe:

Joe L. schrieb:

Tatsächlich musste auch ich mich lange mit "Normalen"/AN-Taschenrechnern rumärgern ...

Als Schüler hatte ich ausschließlich Taschenrechner mit Infixeingabe zur Verfügung. Erst nach ein paar Semestern Studium habe ich mir einen HP geleistet und fühlte mich damit vom ersten Tag an wohler als mit allen anderen Rechnern zuvor. Am schwersten tue ich bis heute mit den Rechnern, wo unäre Operationen (Wurzel, Vorzeichenwechsel usw.) in Präfixnotation eingegeben werden. Dafür fehlen wohl tatsächlich ein paar Drähte in meinem Gehirn ;-)

Vanye R. schrieb:

Da erkenne ich momentan nicht gerade FORTH.

Ist das Forth des HP48.

Die Programmiersprache des HP48 ist zwar stackorientiert, aber kein Forth.

Christoph K. schrieb:

Gerade mal ins Bücherregal gegriffen.

Nur wenige Programmiersprachen haben Bücher zur Einführung mit so witzigen Comics.

https://www.forth.com/wp-content/uploads/2018/01/Starting-FORTH.pdf

Arduino F. schrieb:

Ja, man kann in Forth schwer lesbare Programme schreiben. Und DAS ist ein gutes Beispiel dafür, wie man es nicht tun sollte.

n1.

Moore hatte ja auch mal angemerkt, dass ein gutes 4th word nur ca. 7 (!) Worte beinhalten sollte.

Andererseits kriegt man unlesbare Programme in fast jeder Programmiersprache hin :D

/regards

Yalu X. schrieb:

In Postfixnotation ist zwar ebenfalls leicht erkennbar, dass es sich um ein Produkt handelt (der letzte Operator ist ein "*"), aber die weitere Analyse des Terms gestaltet sich deutlich schwieriger. 1 2 + 3 4 + *

1

1 2 + 

2

3 4 + 

3

*

solved ...

/regards

Joe L. schrieb:

Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard. Aber ich wiederhole mich...

Ein weiterer antiker Computer der nur UPN konnte weil der zu wenig Bumms hatte. Spätere Computer konnten das UPN dann selbst machen.

Yalu X. schrieb:

Joe L. schrieb:

Forth wurde schon früh als "Write-only Language" bezeichnet.

Woran Forth imho "leidet" ist, dass sich keiner mit RPN (Reverse Polish Notation) beschäftigen will. Ich mag RPN, nicht zuletzt wegen meiner (Vintage-)Taschenrechner von Hewlett Packard.

es mitunter etwas knifflig, eine Idee in Code umzusetzen, dafür ist es umso leichter, diesen Code nach einem Jahr noch zu verstehen.

Harald K. schrieb:

Das ist wohl ein Verdrahtungsding. Der Taschenrechner, mit dem man zuerst konfrontiert wird, der prägt einen, und die Logik brennt sich ins Hirn ein. Das später zu ändern ist mühsam, schwer bis unmöglich.

Der HP35 war mein erster Taschenrechner. Der hatte damals noch den ln 2.02 Fehler, falsches Ergebnis, und HP lieferte ein neues Gerät.

Arduino F. schrieb:

Ja, man kann in Forth schwer lesbare Programme schreiben. Und DAS ist ein gutes Beispiel dafür, wie man es nicht tun sollte.

Sagt jeder Fanboy von krudem Zeug, wenn er mit der Realität des Unsinns, den er so hochjubelt, konfrontiert wird.

Auch HP hat UPN nicht eingeführt weil es so geil war, sondern weil der Speicher der frühen Taschenrechner extrem knapp war, da musste halt ein Teil der Formelverarbeitung auf den Bediener outgesourct werden.

Mach dir keine Sorgen, du bist nicht der einige, der zu beschränkt ist, um sich auf Forth einzulassen. Für den UPN die völlige Überforderung darstellt.

Kümmere dich einfach um andere Sprachen. Forth ist offensichtlich nix für dich.

PS: Die Infix Notation wird schon in der Grundschule gelehrt. Da ist es ganz natürlich, dass sich bornierte Leute da nie wieder von lösen können.

Arduino F. schrieb:

Ja, man kann in Forth schwer lesbare Programme schreiben.

Gibt es Gegenbeispiele, also /gut lesbare/ Programme in Forth?

Christoph K. schrieb:

Da erkenne ich momentan nicht gerade FORTH.

Zumal ich ! für Store in Erinnerung habe. Ein besonderes Merkmal von FORTH ist aber, die Sprache in nullkommanix bis zur völligen Unkenntlichkeit verändern zu können.

˙ɟ uɐɟǝʇs schrieb:

, aber das sieht für mich aus, wie Ägyptische Hieroglyphen.

Kein Bisschen. Für Altsprachler gibt es APL. Game of life in APL:

1

life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}

(prx) A. K. schrieb:

die Sprache in nullkommanix bis zur völligen Unkenntlichkeit verändern zu können.

Es gibt zwar einen "üblichen" Wortschatz, aber keinen zwingend immer vorhandenen.

Eigentlich gibt es nur eine einzige zwingende Regel: Wörter müssen durch Whitespaces voneinander getrennt notiert werden. Das ist alles. Mehr nicht. Alles andere ist frei definierbar, auch zur Laufzeit austauschbar. OK, man kann nur Worte verwenden, welche vorher definiert wurden.

Harald K. schrieb:

Das ist wohl ein Verdrahtungsding.

Zumindestens kann eine besondere Programmiersprache auch eine besondere Denkweise erfordern. Gerade APL, mit dem ich anfing.

PS: Für gut gemeinte Kommentare bin ich offen. ;-)

Forth ist eine Programmiersprache in der man sich zuerst einmal die für den jeweiligen Anwendungszweck notwendig erscheinenden Worte erstellt. Diverse Berechnungen, Sensorabfrage, Maschinensteuerung,usw. Dann folgt darauf aufbauend das eigentliche Programm. Wenn man das kann - also wenn man seine Gedanken vorab gut ordnen kann - funktioniert so etwas sehr gut.

(prx) A. K. schrieb:

Ein besonderes Merkmal von FORTH ist aber, ...

Vermutlich gab es deshalb schon bei Forth sehr früh die Möglichkeit viele Kommentare in den Sourcecode zu schreiben (64k Limit).

Andreas H. schrieb:

Yalu X. schrieb:

In Postfixnotation ist zwar ebenfalls leicht erkennbar, dass es sich um ein Produkt handelt (der letzte Operator ist ein "*"), aber die weitere Analyse des Terms gestaltet sich deutlich schwieriger. 1 2 + 3 4 + *

1 2 + 3 4 + *

Ja, so wird der Ausdruck auch in Forth übersichtlich. An dieser Notation stört mich allerdings ein wenig, dass jede Einzeloperation eine ganze Zeile benötigt. Das kenne ich sonst nur von Assembler, AWL und Bascom.

Yalu X. schrieb:

An dieser Notation stört mich allerdings ein wenig, dass jede Einzeloperation eine ganze Zeile benötigt.

Selbst wenn es dich stört... Aber so lassen sich für jede Zeile Stackkommentare setzen.

Das ist für Erfahrene vielleicht nicht ganz so wichtig, aber der Einsteiger wird dankbar sein

Arduino F. schrieb:

Es gibt zwar einen "üblichen" Wortschatz, aber keinen zwingend immer vorhandenen.

Es gibt seit 1994 eine ANSI-Norm zu Forth, da steht drin, was zwingend ist.

Fakt ist aber eben auch, daß Forth die einzige professionell einsetzbare Programmiersprache ist, in der sich auch ein einigermaßen begabter Programmierer seinen eigenen Interpreter/Compiler stricken kann und auf Standards pfeifen kann (siehe Jonesforth, oft gelobt). Weshalb es in Forth wohl noch mehr Dialekte als in Basic gibt. Manchmal habe ich den Eindruck, es gibt mehr Forth-Dialekte als Forth-Prorammierer ;-)

Gruß Klaus (der soundsovielte)

Man brauch eben eine mitlaufende Dokumentation inkl. aller Tricks und des eigentlichen Algorithmus.

Ich habe einige ältere meinige Sims in LTspice sogar als Schaltplan, die ich auch nicht mehr verstehe oder sehr lange drüber sinnen muß, was ich da anstellte. Immer ist der Grund Faulheit weglassen der Doku.

Yalu X. schrieb:

An dieser Notation stört mich allerdings ein wenig, dass jede Einzeloperation eine ganze Zeile benötigt.

Yalu X. schrieb:

An dieser Notation stört mich allerdings ein wenig, dass jede Einzeloperation eine ganze Zeile benötigt.

Würde ja auch kein UPN kompatibler Mensch so schreiben. Es war nur Verdeutlichung ;)

Und wie schon allgemein festgestellt: Schlechte Programme kann man in jeder Programmiersprache schreiben ;)

/regards

Klaus S. schrieb:

Fakt ist aber eben auch, daß Forth die einzige professionell einsetzbare Programmiersprache ist, in der sich auch ein einigermaßen begabter Programmierer seinen eigenen Interpreter/Compiler stricken kann und auf Standards pfeifen kann (siehe Jonesforth, oft gelobt).

In Common Lisp ist es auch üblich sich die Sprache so anzupassen, dass sie besser zum Problem passt (defmacro ...). Dabei pfeifen die Jungs aber normalerweise NICHT auf Standards. Das erzeugt nur unnötigen Mehraufwand.

Auch so eine Sprache von der die Arduinogeneration glaubt sie sei ausgestorben. Aber vermutlich schauen die auch alle um den 6.12. neugierig in ihre Schuhchen ;)

/regards