
Historical recreation/restoration of original Forth on the IBM 1130 - kencausey
https://rescue1130.blogspot.com/2018/03/historical-recreationrestoration-of.html
======
alatz
I was about to write something encouraging people to learn FORTH, but after
some consideration, I started having second thoughts.

I _really_ like FORTH, but I think it promotes some subversive/extreme views
which can sow seeds of discontent (or at least it did for me).

Much of my dissolution with the business of programming can be traced back to
learning FORTH. It showed me just how much is possible if you optimize for
simplicity, and it encouraged me to ask the question: maybe the trade-offs in
programming aren't necessary i.e. we don't need to trade complexity for
functionality? Now that I have some distance, I was/am probably wrong, and
they are necessary, but this question still bugs me.

After learning FORTH I enjoyed my job less. I no longer had the patience I
once had for the build tool breaking the umpteenth time, or dealing with yet
another poorly documented and barely working REST API.

To be fair, this probably wasn't FORTH's fault. Waning enthusiasm may happen
naturally as you gain experience in the industry, but it certainly seemed to
accelerate the process.

Anyway, FORTH is awesome, but maybe you shouldn't learn it.

~~~
sosilkj
Any book/resource recommendations for learning Forth?

~~~
alatz
If you want to take the plunge, jhbadger's recommendations of starting FORTH
and thinking FORTH are both great. Starting FORTH covers the language itself,
whereas thinking FORTH deals more with the philosophy of FORTH and programming
in general.

If you really want to get serious, writing your own FORTH, which is a kind of
right of passage in the FORTH community, is a good way to learn. While
somewhat controversial among FORTH purists (for reasons I don't entirely
understand), I would recommend Richard Jones' jonesforth as reference for
this:
[https://github.com/nornagon/jonesforth/blob/master/jonesfort...](https://github.com/nornagon/jonesforth/blob/master/jonesforth.S)

~~~
sosilkj
Thank you to you and jhbadger for these great links.

------
richard_shelton
I have programmed for years with Forth and I really think it was not a wasting
of the time for me. I had very interesting Forth-related job, I became more
proficient in PL design/compilers-related things because of Forth.

Alas, I don't think that Forth is very relevant today in the professional SW
development. But it's still a great teaching tool. I would like to see, for
example, a PL design course where first pages would be about META II and Forth
implementations.

Modern programmers need more examples of beautiful, miniature software
architectures. Tools like Forth are especially interesting, because they show
us that even a single developer may do great handcrafted things and he doesn't
need to depend on third-party tools, IDEs, frameworks for it. Charles Moore
haven't invented Forth from scratch, he "synthesized" it from some really
great ideas of 50-60s, like Lisp, B5000, APL etc. Moore took only those parts,
which were good components (simple to implement, understand, combine) to build
his own independent tool. N. Wirth uses the similiar approach, by the way.

Maybe today we could repeat the same synthesis/minimisation process with some
modern ideas/technologies to create a beautiful tool for a modern programmer -
lone craftsman. Or maybe the whole "tool-making" (see Whole Earth Catalog etc)
movement is just a thing from the past?

~~~
exikyut
META II appears to have been a DSL that used a more straightforward equivalent
of BNF and transpiled/metacompiled it to a RPN-parsing VM. It was built around
1963.

[https://en.wikipedia.org/wiki/META_II](https://en.wikipedia.org/wiki/META_II)

------
s-macke
I wonder if Forth is still used today for some applications of if anyone has
stumbled over some production Forth code lately.

For me, Forth is a language in which you can easily shoot yourself in the
foot. One element more or less on the stack and you run into strange problems
ten functions later in your code. But what I especially like is the enhanced
naming of "words". You can choose "variable" or "function" names such as
"a->b" instead of "a2b()" or "a_to_b()". Or "@X" for "GetX()" and "!X" for
"PutX()".

~~~
agapon
FreeBSD uses Forth as a scripting language of its boot chain. illumos had
recently started using the same boot chain.

~~~
sedachv
They are replacing it with a Lua-scripted bootloader:
[https://readlist.com/lists/freebsd.org/freebsd-
current/25/12...](https://readlist.com/lists/freebsd.org/freebsd-
current/25/125211.html)

Apparently one of the "features" motivating the decision to use Lua is "it's
interpreter is very small (~240 KB)," which sounds like a dumb joke when you
consider Forth's footprint.

------
dwarman
I still use a version of FORTH as an embedded debug tool, have done for
several different CPU architectures over the years. I wrote some extensions
that help to offset the "double edged sword with no handles" danger, such as
local methods, call/return prototypong (basically formalize=ing the
conventional word definition comment, which I also snag as is into definitions
as a help string) that garuntees stack frame handling on entry and exit. Also
wrote an auto-translater for C wrappers of function calls and struct
definitions to get symbolc interaction with the code being debugged. Really
speeds up behavioral debugging (Real Time systems have to be runnig to
diagnose, not halted and flayed open on the operating table like breakpoint
debugging does).

------
GnarfGnarf
The IBM 1130 was a great little machine. I wrote a high school course
scheduling program on it in 1969 at the Universidad de San Andres in La Paz,
Bolivia. Highest university in the World (12,000 ft).

------
danbmil99
Anyone interested in the theory and practice of programming languages should
know about and appreciate FORTH for the sheer beauty of it.

Everyone else should start with Python.

