Can you please suggest any reference which explores forth in depth and goes into the subtleties. I am starting out on the Leo Brodie books.
Two books: (I really enjoyed the first one, multiple times)
"Threaded Interpretive Languages", by R. G. Loeliger.
"Stack Computers: The New Wave", by Philip Koopman.
Two short papers: (maybe not profound, but they're short and available online)
"Handling Multiple Data Types in Forth", by John J Wavrik. https://www.math.ucsd.edu/~jwavrik/pub/11_jfar.pdf
"Literate Programming in Forth", by Peter Knaggs. https://rigwit.co.uk/papers/literate.html
"Object Oriented Forth" by Dick Pountain is a succinct and practical exploration of applying Forth's metaprogramming capabilities to extend the language with various features. The best aspect of the book is that it works through many alternatives rather than taking a direct path. It's more about data structures and abstraction than OOP.
Julian Noble (https://www.taygeta.com/fsl/docs/NobleArchive.html) also wrote a number of very interesting articles and books about Forth. There's an apparently ongoing project to re-typeset his "Scientific Forth": https://github.com/Josefg/Scientific_FORTH.
I think the heart of the problem is that the rudimentary ideas of forth- a stack, some stack-shuffling words, some arithmetic, control flow, and that's about it- are appealingly simple, but not enough of the language:
>"I figured I didn't need the more interesting metaprogramming stuff for my first prototype programs, and I could add it later if it turned out that I was wrong. It was wierd to throw away everything I originally liked the most, but I was all set to start writing real programs. Solving real problems in the real world. It was among the most painful programming experiences in my life."
Imagine reading the first chapter of SICP without prior exposure to Lisp, excitedly writing an interpreter for the parts of the language you'd seen so far, and then feeling your enthusiasm slowly slip away into dismay as you attempted to use that stunted fragment of a language to get work done.
Forth can be small, and simple, but the real gems of the language are a bit subtle. The many implications of CREATE>/DOES. Abuses of manipulating the rstack. Striking a balance between parsing words, named locals, global variables, vocabularies, and other tools to minimize twisty stack shuffling. Bending the rules at the right times.