Collapse OS – Why Forth? | Dark Hacker News

Collapse OS – Why Forth?(collapseos.org)

281 points by crousto 5 years ago | 166 comments

megameter 5 years ago |

If I had to put my finger on why Forth is hard for most programmers, it's like this: the structured program theorem suggests using sequence, selection, and iteration to control program logic. Assembly code on hardware architectures will assign all meaning sequence-relative, late-binding the selection and iteration. Forth doubles down on this sequence-first approach through a more versatile assignment mode(the stack) while only minimally accommodating the other two. That makes it easy to implement, while not explicitly addressing expressability.

Forth written "flat" with shallow data stack usage is assembly by another name, a wrapper for load-and-store; Forth that does everything with intricate stack manipulation is a source of endless puzzles since it quickly goes write-only.

But, like any good language with meta expression capabilities, you can work your way up towards complex constructs in Forth, and write words that enforce whatever conceptual boundaries are needed and thus check your work and use the system as a compiler. That's what breaks Forth away from being a simple macro-assembler. But you have to write it in that direction, and design the system that makes sense for the task from the very beginning. That falls into an unacceptable trade-off really easily in our current world, where the majority of developers are relatively inexperienced consumers of innumerable dependencies.

theamk 5 years ago | |

For me, the main problem with forth is a lack of names -- most languages (functional or imperative or even declarative) assign names to things -- things like function parameters, temporary values and so on.

Even Prolog, which is as far from traditional structural program as one can go, usually has descriptive names for unbound variables.

Compared to this, Forth is very name-terse. You get "function names" at best, and nothing else. This really makes programs much harder to understand, as it requires one to remember much more things while reading the code.

chalst 5 years ago | | |

The ANS Forth standard supports named local variables. Unfortunately Forth dialects vary quite a bit in their implementation and prefered use of local variables, and the semantics of local variables are a bit hairy.

Cf. https://www.complang.tuwien.ac.at/forth/gforth/Docs-html/ANS...

TurboHaskal 5 years ago | | |

Note that Forth also supports locals. These will consume and remove N members from the stack so you can summon them as needed prior to calling the words.

But as someone that really got into Forth this year, I can assure that it does get better once you get more familiar with the language. I used to write commenting the stack effects on each line and now I barely need them as I write words in one sitting without that much effort.

Other developers are doing tacit programming in J or Haskell, pipe forward operators in F# or OCaml and threading macros on Lisp dialects and they seem to do fine.

yiyus 5 years ago | | |

The term you are looking for is "tacit" or "point-free" programming. Array languages are another example.

boomlinde 5 years ago | | |

You're right in the sense that it's not in style, but there are both named "locals" and "arguments" in ANS Forth IIRC.

monadic2 5 years ago | |

> But, like any good language with meta expression capabilities, you can work your way up towards complex constructs in Forth, and write words that enforce whatever conceptual boundaries are needed and thus check your work and use the system as a compiler. That's what breaks Forth away from being a simple macro-assembler. But you have to write it in that direction, and design the system that makes sense for the task from the very beginning. That falls into an unacceptable trade-off really easily in our current world, where the majority of developers are relatively inexperienced consumers of innumerable dependencies.

Well expressed, I often think of the stack as the syntax of the language, not the runtime implementation, and it is quite difficult to hire for this skill without spending a lot of money.

andrewflnr 5 years ago | |

Interesting perspective. For anyone else who wasn't familiar with this usage of "selection": https://en.wikipedia.org/wiki/Structured_program_theorem

justin66 5 years ago | |

> Forth is hard for most programmers

It's pretty hard to make that judgment. I'd guess at least 99% of programmers have never used Forth.

chii 5 years ago | |

> That falls into an unacceptable trade-off really easily in our current world, where the majority of developers are relatively inexperienced consumers of innumerable dependencies.

aka, this is hard to do, and a difficult mental model to learn. It's the same kind of thing with LISP'y languages and functional languages (not the same model, but the same level of difficulty).

jacquesm 5 years ago | |

That's just about right. To put it more concisely: Forth only works well when used properly: as a very easy to extend DSL.

jstanley 5 years ago |

If this gets you interested in z80 hardware, I would recommend building an RC2014: https://rc2014.co.uk/

I built an RC2014 after CollapseOS was posted last year, and thoroughly enjoyed it.

I ended up adding a front panel, complete with switches and lights, to allow toggling in and executing code without a ROM, and also wrote a HTTP/1.0 server for CP/M (which was an enormous headache for lots of different reasons). Never did get around to running CollapseOS on it though.

zentiggr 5 years ago |

I think I've had my own moment of clarity that spans both Forth(s) and Lisp(s) and explains why neither is as common as other languages.

In most common languages, there is a complicated base spec that covers many cases and defines a broad range of affordances, plus libraries and libraries that expand on an already fleshed out collection of tools and etc.

Forths and Lisps give you the core of an environment, and let/expect you to build on the foundation to create your own implementation. Like someone else in this thread said, N programmers, N dialects. Or, more accurately, every Forth program is its own DSL for accomplishing its work.

ojnabieoot 5 years ago |

I hate this headline but the project is very cool. People like me who were ignorant should start here instead of the Github to get a better sense of the design goals (and why they are using Forth): https://collapseos.org/forth.html

bsaul 5 years ago |

First time i hear about this project and i love it.

I often talk with a friend who's an historian, and that makes me realize how our relationship with time, as an industry, is extremely short sighted.

The internet archive is an immensely valuable project, as well as all the websites archiving old documentation, etc. But i don't think a lot of people realize the value of things they're destroying everytime they execute a delete statement in a DB or a filesystem.

This Collapse OS ambition to be able to "bootstrap" something useful over any kind of primitive hardware and sustain the passage of time ( or catastrophic event) may have an immense value in the future.

onetom 5 years ago | |

DELETE statement... That's far too obvious. With every UPDATE statement you are forgetting the past, yet it's still the goto DB paradigm! It's okay to constantly lose information apparently...

And it's not like we don't have alternatives. There is Datomic of course, but also juxt/crux and DataHike.

Narishma 5 years ago |

> The Z80 asm version of Collapse OS self-hosts on a RC2014 with a 5K shell on ROM, a 5K assembler binary loaded in RAM from SD card (but that could be in ROM, that's why I count it as ROM in my project's feature highlights) and 8K of RAM. That is, it can assemble itself from source within those resources.

Meanwhile, you can't compile rustc on a 32-bit system because it runs out of address space...

dreamcompiler 5 years ago |

There seems to be a common conception that Forth is always interpreted by some kind of virtual machine. But it's quite possible to compile Forth all the way down to native machine instructions with no loss of interactivity and without losing the rapid bootstrap capability the author describes. Such a Forth runs almost as fast as C (almost because modern out-of-order and other processor optimizations probably don't work well on compiled Forth code).

I used this approach when I bootstrapped a Forth compiler on the TI 34010 graphics chip in a similar fashion as the author. It even had local variables so you didn't drive yourself mad thinking about the stack all the time.

My favorite commercial example of such a Forth was Mach 2 Forth on the early (pre-OSX) Macs. I don't know if any modern Forths do down-to-the-metal compiling or local variables, but I'd be interested to find out.

ehaliewicz2 5 years ago | |

> local variables

I believe most modern forths will have these, gnuforth does for example.

> down-to-the-metal compiling

I think there are some that do this, but back in the day, the opinion of lots of forth programmers was that threaded code was good for the 90% of the program where performance didn't matter, and added an inline assembler for areas where it did.

Someone 5 years ago | | |

And of course, you can always add support for local variables yourself. For an example, see http://turboforth.net/resources/locals.html, which takes 808 bytes to implement. That’s hefty, for some systems where one would use Forth, but, FTA, “Placing key values in locals will actually both increase peformance, and make your code smaller”, so you can earn that back if you use the facility enough)

krick 5 years ago |

I thought this is pretty fun project and the idea is just cool right away, but then I went on reading and was surprised by the fact it seems the author is serious. I would be really curious to hear his opinion on why the supply chains should collapse before 2030. Obviously, there wouldn't be a shortage of people in the comments who can start speculating on why it might happen, and, of course, I myself also can provide a couple of feasible scenarios, but nobody of us were serious enough to actually start this project, so his opinion on the matter is somehow quite more interesting to me than it would normally be.

onetom 5 years ago |

I'm surprised that no one has mentioned https://flashforth.com/

There is no intriguing backstory for it, like for CollapseOS, but it's a ~6 kiloword, practical 4th environment for Microchip PIC microcontrollers, which are a lot simpler than Z80, btw... The source code is trivial to understand too. My father is still using it daily to replace/substitute Caterpillar machine electronics or build custom instruments for biological research projects.

We started with Mary(Forth) back then, when the first, very constrained PIC models came out, with 8 deep stack and ~200 bytes of RAM. Later we used the https://rfc1149.net/devel/picforth.html compiler for those, which doesn't provide an interactive environment.

I made a MIDI "flute" with that for example, which was fabricated from sawing out a row of keys from a keyboard and used a pen house as a blow pipe and a bent razor with a photo-gate as the blow-pressure detector...

There are more minimal Forth OSes, which might be more accessible than a Z80-based one.

I would think those are more convenient for learning, how can you have video, keyboard and disk IO, an interactive REPL and compiler in less than 10KB

I remember, I played a lot with https://wiki.c2.com/?EnthForth

But if you really want to see something mind-bending, then you should study Moore's ColorForth! I found it completely unusable, BUT I've learnt immense amount of stuff from it: https://colorforth.github.io/

There are more usable variants of it, btw. Also worth looking into Low Fat computing: http://www.ultratechnology.com/lowfat.htm I think it's still relevant today.

TheUndead96 5 years ago |

The weird thing about history is that it only makes sense backwards. Someone 500 years in the future might think of this as the Gutenberg printing press. It is often difficult to appreciate the magnitude of actions in the present.

hutzlibu 5 years ago | |

Why should they think that?

The gutenberg press was used in the real world. There are lots of OS being used in the real world for real work.

So why should someone in 500 years think this is more relevant, than for example Linux?

And if there is a real collapse, then I also do not really believe everyone makes a run for collapseOS. There are other options: all the ones, tinkerers and hackers use already today.

TheUndead96 5 years ago | | |

We don't know how history will pan out. Just wanted to share the weird feeling I sometimes have about current events. For all we know, post-collapse technology could be based off QMX reverse-engineered from luxury vehicles. It's just fun to think about how events can have that unexpected butterfly effect. I sometimes catch myself with the implicit belief that we are "late" in the story of history. But given the possible expanse of time, we might be the "hunter-gatherers" of a civilization we cannot even begin to comprehend. This might just be the second of the dark ages.

RodgerTheGreat 5 years ago |

I'm delighted to see that hsoft took suggestions about Forth to heart, and that it has lead to both simplification and enrichment of the project.

tarkin2 5 years ago |

I love this project. Thank you for posting it. The idea of a post collapse operating system reminds me of slackware/subgenius’s old slogan: “...the world ends tomorrow and you may die!”

I’ll be trying to compile collapseos, write forth and load slackware on floppys in a few years then. (Will systemd survive civilisation’s collapse, especially when it caused it, that is the question....)

mhd 5 years ago | |

For me this is slightly into Poe's Law territory: Is this actual prepper mindset, or tongue-in-cheek?

tarkin2 5 years ago | | |

Thanks. I'd never heard of that law before. I think he's serious. I'll appreciate his work both pre and pos civilisation collapse. I like his software aesthetic too.

Maybe I'm getting old, maybe I'm seeking more control, maybe the world has come needlessly complex, but there's a certain appeal about returning to more manageable days, where it was possible to fit a software and hardware system in your brain, and your brain was swimming with ideas on how to use a limited system rather than drowning in layers of complexity.

haolez 5 years ago |

> Some Forth enthusiasts like the language for itself. They think that its easier to express much of the logic of a program in this language. Many books and tutorials are touting this. [...] That's not my opinion.

In my opinion, it's not that FORTH code is hard to read, but that FORTH gives the programmer so much freedom that every program becomes its own microcosm of DSLs.

DonHopkins 5 years ago | |

    : C(-; LICK SMILE NOSE WINK ;

( See my profile for more microcosmic FORTH DSLs! )

c(-;

https://news.ycombinator.com/user?id=DonHopkins

pwdisswordfish2 5 years ago |

https://collapseos.org/why.html

"That being said, I don't consider it unreasonable to not believe that collapse is likely to happen by 2030, so please, don't feel attacked by my beliefs."

Triple negative? Quadruple negative? (If we count the second "don't".)

Compare something like:

"I consider it reasonable to believe that collapse is unlikely to happen by 2030, so please, don't feel attacked by my beliefs."

It is almost as if the grammatical structure reflects the life perspective of the author.

krick 5 years ago | |

I don't really want to participate in developing this silly argument, but people making such comments should always consider the possibility that there is a reason for somebody to say things the way they do, and that your "simplification" in fact loses the point of what author is trying to say.

So let me translate for you.

He doesn't "consider it reasonable to believe that collapse is unlikely to happen by 2030", in fact he believes that given the importance of the matter, he is better to assume the scenario, in which his project will turn out to be life-saving. But if it doesn't seem likely to you, that collapse will happen before 2030, and you don't believe the evidence supporting that claim, he wouldn't call you silly (unreasonable) for that, so we (he and you) can work on the project together even if our forecasts are different, don't worry about that too much.

csb6 5 years ago | |

This is the perfect comment - pedantic, snarky, and more focused on the superficial features of the article than the content, mixed in with some grammatical pseudo-psychology. Check, check, check, and check! This is peak tediousness. Well done!

bondarchuk 5 years ago | |

>It is almost as if the grammatical structure reflects the life perspective of the author.

That seems like a perfectly valid thing for grammatical structure to do, although this one tripped me up admittedly.

0-_-0 5 years ago | |

Hmmm, let's see if I can make it worse:

"That being said, I don't consider it unreasonable to not believe that collapse is unlikely to not happen by 2030"

microcolonel 5 years ago | |

There's a difference between “not unreasonable” and “reasonable”.

pwdisswordfish2 5 years ago | | |

Can you provide more details?

messe 5 years ago |

Nice. Must revisit my own Forth OS, or maybe just start contributing to this.

mshockwave 5 years ago |

this might be a dumb question but can someone briefly explain why Forth is more suitable over C or other languages in general on post-apocalyptic OS?

yellowapple 5 years ago | |

- It's tiny and dead simple to implement

- It sits very close to assembly

- It allows high-level programming like in C

- The concept of pushing/popping things onto/off the stack is a relatively straightforward programming model when done consistently

One of the old competitors to the likes of UEFI and uBoot is OpenFirmware (also known as OpenBoot), for which the primary UI is a Forth shell; OpenFirmware was the BIOS equivalent for Sun's SPARC workstations/servers (and still is for Oracle's/Fujistu's SPARC servers, last I checked) and most POWER hardware (including "New World" PowerPC Macs), among others. About the most delightful pre-boot environment I've used; it's a shame it didn't catch on in the x86 or ARM space.

chalst 5 years ago | | |

In some ways it is even more abstraction-friendly than C because of how easy it is to manipulate functions or redefine its own interpreter/compiler. There was a nice example of a Tiny C compiler written in Forth by Marcel Hendrix posted to comp.lang.forth, with a Forth-defined VM as target. I posted a story about it at https://news.ycombinator.com/item?id=23455548

The big problem with Forth is software reliability: ad-hoc Forth code is hard to reason about in any generality. Languages like Factor show that dialects of Forth can be much better in this regard.

fouc 5 years ago | | |

Also works great with graphics. PostScript is similar to Forth.

Avshalom 5 years ago | |

https://github.com/nornagon/jonesforth/blob/master/jonesfort...

This is (the now pedagogically famous) JonesForth. It's ~2000 lines of HEAVILY commented assembly, and at then you have everything you need to start writing a fully functional Forth+standard library (which is done in jonesforth.f in a ~1800 lines of heavily commented forth). That's not even as tiny as forth can be, and it gives you a lowish level language that is as/more modifiable and extensible as any Lisp.

There is basically no faster way to get from bare metal to a comfortable humane and interactive (so you can write more stuff) computing environment than writing a forth.

gridlockd 5 years ago | |

It is very small.

cygx 5 years ago | |

easier bootstrapping

bitwize 5 years ago |

This is the kind of malarkey I'd get up to on a personal project of mine. Like, I wonder if I'd get farther if I'd written it in Forth/TinyScheme/Erlang? May as well completely overhaul it and find out!

jvanderbot 5 years ago |

I feel sheepish for being on that thread as a detractor, after reading this post.

redisman 5 years ago |

Love this project. I wonder why not make it run on smartphones? I'd imagine that's the vast majority of computers out there today. Easier to find a working smartphone than retro consoles.

eloisius 5 years ago | |

He explained that a bit here[1]. The project targets a world wherein existing computers have degraded to a point beyond repair and we have to scavenge parts that can be retrofitted. His reasoning is that under such conditions, parts that can be thru-hole soldered such as 8-bit z80 CPUs will be much more robust than surface mounted ARM chips.

1: https://collapseos.org/why.html

Cthulhu_ 5 years ago | |

Usually it's nontrivial to get anything custom to run on a smartphone, they're pretty locked down like that compared to more general hardware.

Koshkin 5 years ago |

CollapseOS? Meh. What we need is ApocalypsOS. Something to play Tetris on after having hauled a bucket of wellwater (and some wood) to the 23-rd floor apartment where I try to survive.

dang 5 years ago |

See also https://news.ycombinator.com/item?id=21182628 from last year.

MaxBarraclough 5 years ago |

On the topic of compactness: is FORTH ever used in the demoscene?

As I understand it, they tend to write assembly, and compress the resulting machine code, for decompression at runtime.

jbb67 5 years ago |

I want to learn forth now. Where can I find a modern usable forth that works well on windows to make real programs? Does such a thing even exist?

TurboHaskal 5 years ago | |

You can do just fine with the free versions of SwiftForth and VFX Forth as long as you don't mind that they are 32bit only.

If you end up liking it and want 64bit, you can buy iForth for 100 EUR. It's what I use.

These are all amazing optimizing compilers.

If you care about OSS: Don't waste your time with GForth. If you want something simple that you can hack yourself, take a look at pforth.

anthk 5 years ago | | |

This. Pforth works really well and the ".S" word is straightforward, while pfe is not. GForth is too difficult; altough you can code for the Game Boy with it, but in order to learn, pforth is more than enough.

fouc 5 years ago |

I keep hoping that a Rubyist will someday do the same thing for Forth like José Valim did for Erlang, with Elixir.

pwdisswordfish2 5 years ago |

Here is a Forth you can use on Linux and Windows

http://web.archive.org/web/20080828064920/http://ronware.org...

garmaine 5 years ago |

Forth is Lisp, but with composition as the basic operator instead of application. The result, of course, is a wildly different language but one which inspired the same degree of fanaticism among its adherents in their search for simplicity and elegance.

A truly under appreciated language imho.

RodgerTheGreat 5 years ago | |

I rather disagree with your first sentence. Forth is not Lisp, nor is Prolog or APL Lisp, and none of these languages are one short conceptual leap away from the others. Even a very rudimentary Forth can express concepts which have only hazy correspondences in a Lisp, like words which twiddle the return stack or yield a variable number of results on the parameter stack.

I find it misleading at best to casually intimate that Lisp is some kind of ur-language which exemplifies simplicity and thus lies at the root of any design space. Fans of Lisp are overly eager to stake claim upon ideas which do not belong to their language.

I don't mean to bite your head off about it; this is just a trope I find tremendously frustrating.

garmaine 5 years ago | | |

The core of Lisp is a small set of rules about abstraction and application using lists. Forth, at its core, can be formalized with the exact same set of rules (one to one correspondence) but with stacks and composition as the operator. The languages are very VERY different, but there is a similar bare bone formal framework at the bottom.

newaccount86 5 years ago | | |

This article talks about “linear lisp” with a stack and you basically end up with something forth-like. http://home.pipeline.com/~hbaker1/ForthStack.html Linear Logic and Permutation Stacks--The Forth Shall Be First

dreamcompiler 5 years ago | | |

What Forth and Lisp have in common is that they're interactive language construction sets. You don't just write domain code the way you do in C. You invent a language that matches the domain and use that to solve the problem. Don't like the syntax? Change it. Don't like the conditional statement? Invent a new one. Don't like the compiler? Improve it.

These kinds of operations are behind the curtain in C but they're accessible to everybody in Forth and Lisp.

detaro 5 years ago |

somewhat OT, but are there any active Forth communities/forums to follow if one wants to see what people get up to with it?

tibbydudeza 5 years ago |

And all I wanted was a pipboy.

johnisgood 5 years ago |

Why not Factor? :P

TurboHaskal 5 years ago | |

Because Forth is more (less?) than a Smalltalk on RPN.

RandomGuyDTB 5 years ago |

It's odd to highlight that Forth is 50 years old, considering C is 48 years old and still in very heavy use in operating systems development.

crousto 5 years ago | |

Collapse OS was initially written in assembly for the Z80, a microprocessor first launched in 1976. The fact that Forth is 6 years older than the Z80 seems interesting enough of a step further back in time to be hightlighted.

downerending 5 years ago | |

I suspect that a lot of readers have no idea how old it is.

(I, on the other hand, have to be reminded that 50 years have passed.)

lstodd 5 years ago | |

It's odd to compare C and Forth. They are so different.

Edit: as someone below mentioned there can not be a 'Standard Forth'. You just write your own one as you see fit.

bitwize 5 years ago | | |

There's ANS Forth. Chuck Moore doesn't like it, but it exists.

CameronNemo 5 years ago | |

Perhaps Forth has changed less than C in that time. The C of 48 years ago can look quite different from modern C.

RodgerTheGreat 5 years ago | | |

There has never been one Forth. In a world with N Forth programmers, one can expect roughly N implementations of Forth. Perhaps closer to 2*N. An ANS spec exists, but most Forth programmers would say it misses the point.

Forth is a collection of ideas and philosophies toward programming as much as it is a language. Two stacks and a dictionary. Threaded code (direct, indirect, token, subroutine, etc...). Collapsed abstractions. No sealed black boxes. Tight factoring.

C has changed. Forth is everchanging.

moonchild 5 years ago | | |

Not really. Function definitions look different, and we can declare variables in the middle of function bodies, but those are surface-level changes. The language itself hasn't changed appreciably.

moonchild 5 years ago | |

Not to mention lisp, in which HN is written.

mlang23 5 years ago |

Forth is one of the last languages on my list. Whenever I read something like this article, I want to learn it. The advice at the end of the article seems interesting. Does anyone have any resources that might help with this?

japanoise 5 years ago | |

A Forth shibboleth is that you have to implement your own in order to understand it. Try reading the assembly, then forth source, for jonesforth: https://github.com/AlexandreAbreu/jonesforth

This is how I learned.

mlang23 5 years ago | | |

Oh wow, thanks. That is pretty much exactly what I was looking for.

monadic2 5 years ago |

Is the focus on forth to rapidly bootstrap from more than just z80, or for readability, or for some other concern?

messe 5 years ago | |

Not the developer, just a forth enthusiast. But I'd imagine it's the ability to rapidly bootstrap on other architectures. Readability is just a bonus on top of that.

The focus of CollapseOS is, well, an OS that can be used after society has collapsed, something running on scavenged chips on hand-soldered boards (in the worst case scenario).

The original logic was the Z80 is still pretty prevalent, so it was thought to be a good choice to base the OS on.

Turns out that a Forth interpreter/compiler is incredibly easy to write (just a few hundred bytes of a assembler, a few thousand at the upper end), so by using Forth they hugely expand the range of scavengeable chips.

imode 5 years ago |

If the author wants their code to survive the apocalypse, they should generate Turing Machines that have a simple shim interpreter for low-power architectures. The benefit of this is you can build an interpreter for a TM in wood or other simple materials. Semi-Thue systems also fit.

imode 5 years ago | |

I don't get why this is downvoted.

carapace 5 years ago | | |

Me neither. I like it but the limiting factor on post-apocalyptic digital electronics will be access to datasheets, eh?

It would be interesting to build a minimal useful CPU out of fluidics. https://en.wikipedia.org/wiki/Fluidics

undershirt 5 years ago |

> Forth doesn't elegantly describe complex algorithms… However, this mental pain does makes you question your need for complexity… This is something that I think few developers are familiar with and is hard to describe with words. It needs to be experienced.

Nice framing, that it’s not an intellectual argument you can make to justify the benefits of drawbacks (i.e. an infamous red flag of stockholm syndrome), so you have to point to the experience of the thing itself (“you had to be there”).

hxegon 5 years ago | |

Or there are experiences which have hard to describe intangible qualities that are hard to put logically. Not sure why you have to reach for stockholm syndrome here.

undershirt 5 years ago | | |

my comment was way off the mark, didn’t realized it sounded sarcastic. i was instead trying to appreciate his approach to the intangible—pointing to direct experience to avoid stockholm criticism.

zentiggr 5 years ago | |

I'll agree with the article's author - there is a quality to a Forth-style solution that just doesn't compare to other languages' styles or overall structure.

When I first heard of Forth and started trying out some of my own code, I was surprised by the initial effort it took me to adjust to writing small words vs C style functions.

I then started building on the pieces I first wrote, and it took very little code to cover my needs.

So yes, there's a very different experience, and it does take adjustment for anyone only familiar with function-style code. And it is not just what I've described, there's a whole different thought pattern involved.