Name: Thinking Forth
ISBN: 9780976458708

Thinking Forth

Thinking Forth applies a philosophy of problem solving and programming style to the unique programming language Forth. Published first in 1984, it could be among the timeless classics of computer books, such as Fred Brooks' The Mythical Man-Month and Donald Knuth's The Art of Computer Programming. Many software engineering principles discussed here have been rediscovered in eXtreme Programming, including (re)factoring, modularity, bottom-up and incremental design. Here you'll find all of those and more, such as the value of analysis and design, described in Leo Brodie's down-to-earth, humorous style, with illustrations, code examples, practical real life applications, illustrative cartoons, and interviews with Forth's inventor, Charles H. Moore as well as other Forth thinkers.

What Hacker News says

anthkApr 2026

- Algol 68 docs: https://algol68-lang.org/resources 'a68g' it's a free as in freedom compiler.

- Forth: you can use PFE,Gforth for ANS Forth requeriments. Or EForth if you reached high skills levels where the missing stuff can be just reimplemented.

EForth under Muxleq: https://github.com/howerj/muxleq I can provide a working config where a 90% of it would be valid across SF.

Starting Forth, ANS version: https://www.forth.com/starting-forth/

Thinking Forth, do this after finishing SF: https://thinking-forth.sourceforge.net/

Also, Forth Scientific Library. You can make it working with both GForth and PFE, just read the docs.

Full pack: https://www.taygeta.com/fsl/library/Library.tgz

Helping Forth code for GForth/PFE. If you put it under scilib/fs-util.fs, load it with:

    s" scilib/fsu-util.fs" included

https://www.taygeta.com/fsl/library/fsl-util.fs

- Lisp. s9fes, it will compile under any nix/Mac/BSD out there, even with MinC.

S9fes: http://www.t3x.org/s9fes/

Pick the bleeding edge version, it will compile just fine.

For Windows users: MinC, install both EXE under Windows. First, minc

exe, then buildtools*exe: https://minc.commandlinerevolution.nl/english/home.html

Then get 7zip to decompress the s9fes TGZ file, cd to that directory, and run 'make'.

Run ./s9 to get the prompt, or ./s9 file.scm where file.scm it's the source code.

In order to learn Scheme, there's are two newbie recommended books before "SICP".

Pick any, CACS, SS, it doesn't matter, both will guide you before SICP, the 'big' book on Scheme:

Simply Scheme https://people.eecs.berkeley.edu/~bh/pdf/

Simply.scm file, select from ';;; simply.scm version 3.13 (8/11/98)' to '(strings-are-numbers #t)' and save it as simply.scm

https://people.eecs.berkeley.edu/~bh/ssch27/appendix-simply....

Concrete Abstractions

Book:

https://www.d.umn.edu/~tcolburn/cs1581/ConcreteAbstractions....

The SCM files needed to be (load "foo.scm") ed in the code in order to do the exercises:

https://github.com/freezoo/scheme-concabs

If you are en Emacs user, just read the Elisp intro, it will work for a different Lisp family but with similar design.

Spot the differences:

Scheme (like s9):

    (define (square x)
     (* x x))

We try:

    >(square 20) 
    400

Elisp/Common Lisp (as the web site shows):

    (defun square (x)
     (* x x))

Same there:

     >(square 20)
     400

- Ok, ML like languages:

https://www.t3x.org/mlite/index.html

If you follow the instructions on compiling s9, mlite it's similar with MinC for Windows. If you are a Unix/Linux/Mac user, you already know how to do that.

You got the whole docs in the TGZ file, and the web.

thread

anthkFeb 2026

9front's manuals will teach you the basics, the actual basics of CS (plan9 intro if you know to adapt yourself, too). These are at /sys/doc. Begin with rc(1), keep upping the levels. You can try 9front in a virtual machine safely. There are instructions to get, download and set it up at https://9front.org .

Write servers/clients with rc(1) and the tools at /bin/aux, such as aux/listen. They already are irc clients and some other tools. Then, do 9front's C book from Nemo.

On floats, try them at 'low level', with Forth. Get Muxleq https://github.com/howerj/mux. Compile it:

          cc -O2 -ffast-math -o muxleq muxleq.c

Edit muxleq.fth, set the constants in the file like this:

      1 constant opt.multi      ( Add in large "pause" primitive )
      1 constant opt.editor     ( Add in Text Editor )
      1 constant opt.info       ( Add info printing function )
      0 constant opt.generate-c ( Generate C code )
      1 constant opt.better-see ( Replace 'see' with better version )
      1 constant opt.control    ( Add in more control structures )
      0 constant opt.allocate   ( Add in "allocate"/"free" )
      1 constant opt.float      ( Add in floating point code )
      0 constant opt.glossary   ( Add in "glossary" word )
      1 constant opt.optimize   ( Enable extra optimization )
      1 constant opt.divmod     ( Use "opDivMod" primitive )
      0 constant opt.self       ( self-interpreter [NOT WORKING] )

Recompile your image:

       ./muxleq muxleq.dec < muxleq.fth > new.dec

New.dec will be your main Forth. Run it:

       ./muxleq new.dec

Get the book from the author, look at the code on how the Floating code it's implemented in software. Learn Forth with the Starting Forth book but for ANS forth, and Thinking Forth after doing Starting Forth. Finally, bacl to 9front, there's the 'cpsbook.pdf' too from Hoare on concurrent programming and threads. That will be incredibily useful in a near future. If you are a Go programmer, well, you are at home with CSP.

Also, compare CSP to the concurrent Forth switching tasks. It's great to compare/debug code in a tiny Forth on Subleq/Muxleq because if your code gets relatively fast, it will fly under GForth and due to constraints you will force yourself to be a much better programmer.

CPU's? Cache's? RAM latency? Muxleq/Subleq behaves nearly the same everywhere depending on your simulation speed. In order to learn, it's there. On real world systems, glibc, the Go runtime, etc, will take care of that making a similar outcome everyhere. If not, most of the people out there will be aware of stuff from SSE2 and up to NEON under ARM.

Hint: they already are code transpilers from Intel dedicated instructions to ARM ones and viceversa.

>How garbage collection works inside of the JVM?

No, but I can figure it a little given the Zenlisp one as a slight approximation. Or... you know, Forth, by hand. And Go which seems easiers and it doesn't need a dog slow VM trying to replicate what Inferno did in the 90's which far less resources.

thread

FarmerPotatoFeb 2026

Still good:

Lee Brodie:

1. Starting Forth. Somewhat dated (1979 FIG-Forth dialect)

2. Thinking Forth. Has software design lessons that go far beyond Forth.

These are free in pdf.

Elizabeth Rather, of Forth Inc:

3. Forth Programming Handbook. What I keep on my desk for Standard Forth.

4. Forth Application Techniques.

Dr. Ting has some good books. They're free pdfs now.

I also keep: Texas Instruments: TI Forth, by Leon Tietz, Leslie O'Hagan... and the vastly improved fbForth manual by Lee Stewart.

thread

fmajidOct 2025

Leo Brodie's book "Thinking Forth" is now free:

https://thinking-forth.sourceforge.net/

thread

DonHopkinsJul 2025

What's "Wrong" with the inventor of FORTH? What do you have against Charles Moore and his programming language? Have you actually tried learning and programming in FORTH? Do you even know what FORTH is, and who Charles Moore is?

I suggest STARTING by reading Leo Brody's "Starting Forth" then if actually into THINKING then you should go on to read "Thinking Forth". But since reading's not really your thing, I get it that you're not actually qualified to say what's "Wrong" with Charles Moore or FORTH.

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

https://www.forth.com/wp-content/uploads/2018/11/thinking-fo...

Would you tell Charles Moore to his face that he's the "Wrong" Charles Moore? Who owns the definition of the "Right" Charles Moore, you? Sounds like you're pretty high and mighty to be so presumptuous about defining who's "Right" and who's "Wrong" while stubbornly refusing to read.

It's not that I'm getting high and mighty (at least not the latter), it's that you're intentionally performatively getting low and ignorant. You're perpetrating a textbook example of sealioning.

Did you or did you not read what the LLOOOOMM simulation of Hunter S Thompson had to say directly to and about you, in response to your posts?

https://lloooomm.com/hunter-willful-ignorance-hn-response.ht...

Your response? Or are you too high and mighty to read it? How can you claim to have a valid opinion about LLM generated content that you refuse to read?

thread

JachJun 2025

Yeah. Pretty much agree with everything here. I'd rather encourage starting with the book Thinking Forth, though. It's not written by Moore but has some commentary from him included in it.

I'd even suggest learning a little Forth to people even if it didn't have its interactive nature (which again I don't actually find useful in my own limited embedded work, there's really no "explore" phase as the problems are all straightforward -- contrary to software I write in CL or even Java). I had a friend in college who for a project made his own language and got it working on an embedded system (I think via compiling to C, but I don't recall exactly), but it was just a boring Algol-like somewhat inspired by Ruby. That pattern has shown up again and again around the world though. Forth is one of the handful of languages that shows what expressive options there are that aren't just transparently Algol-like.

thread