The Evolution of Forth | Hacker News Reader

The Evolution of Forth

forth.com

95 pointstosh18 comments

I suspect the attempts to standardize it and the ANSI standard actually held back Forth somewhat.. I preferred Chuck Moore's forth or forth implementations that eschewed closely to his philosophy.

Agreed. If you ossify what Forth is with an elaborate, prescriptive standard, you lose flexibility; the language can no longer be simplified and reshaped to suit needs.

eschewed -> hewed. I wouldn't normally point typos out, but this one inverts your meaning.

> > forth implementations that eschewed closely to his philosophy.

> this [typo] inverts your meaning.

Actually it doesn't. "forth implementations that eschewed his philosophy" would, but "eschewed closely to" expands to "ommited [stuff] in a manner close to", where stuff would presumably mean (ANSI standard) features. So it's: "forth implementations that eschewed [junk] in a manner close to [what] his philosophy [suggests]". "Hewed" is also fairly correct (and less confusable), though.

Ah thanks!

Chuck Moore should release his colorForth OKAD EDA suite into the public domain as soon as possible. He is not getting any younger and things like Google's Skywater collaboration could really help in popularizing low-overhead self-contained systems.

I agree that I would like to see the colorForth suite in the public domain. At the same time, there are some additional things I want from a prospective language for doing low-overhead systems. I’ve been working on a semi-Forth inspired language and IDE to accompany it, but my hope is it will appeal to a modern audience with additional features, while still maintaining the ability to do extremely customizable systems as the programmer requires.

colorForth itself is in the public domain; it's just OKAD that isn't.

That’s great, I didn’t know the implementation of colorForth was In the public domain. The OKAD layout stuff would be really cool to see, but I don’t have a practical use for it, but I’m always looking for language implementations to dissect.

I am critical of many decisions of the standard, however I disagree that it has held it back. The effort to standardise has been useful and it benefits Forth that there is now a common language for e.g. new learners to start with, before trying out more exotic Forths. Furthermore, the language the standard defines is essentially as useful (or more useful than) many of the idiomatic Forths out there, all inspired by Chuck Moore's earlier Forth.

Chuck Moore's later Forths were attempts to further simplify Forth and take alternative approaches that simply aren't as useful or applicable to the core of Forth programmers, but that Chuck enjoys. He's often said that he makes his Forths for himself and not anyone else, e.g. why he would write a color-based Forth when some people are color-blind. There have been some more applicable and less applicable factorisations, and I see his continuing influence around in different Forths; some standard, some not.

In my opinion, both of you are right. The issue with the standard is not if it is a good or a bad standard; the whole concept of standardization goes against Chuck's approach of writing your own Forth fitted to the problem at hand. However, I think there is no discussion in that the industry preferred a standard to this unlimited freedom, so ANSI-FORTH really helped Forth in industrial settings.

In other words: the standard held back the concept of Forth by Chuck Moore, but it helped to push forward the concept of Forth as an industrial product. A very grey area...

I think the problem is that people going the standardization route were trying to build abstractions. Unfortunately most abstractions built in forth tended to feel rather cumbersome and ineffective to me.

What Chuck Moore mostly did was focus on simplifying the problem such that he can avoid as much abstraction as possible. Which isn't a very accessible way of development perhaps.

I'm not sure if there's a good middle ground between these two approaches..

Can you be specific?

Ah, the holy trinity of languages: Forth, Smalltalk and Lisp. The BMW Isetta, NSU Ro80 and Citroen SM of the programming world. Sure you'd love to own all three but nobody is taking a business road trip in any of them.

However the Forth story is fascinating its well worth reading the entire article.

I like your holy trinity quip. :)

It's interesting that most people acknowledge that each of these languages have some novel insight into program development and yet they tend to be not part of the mainstream.

Is it because the concepts they introduced where just migrated into existing languages and sub-systems? Functions, lists, OOP and stack based virtual machines are common place now.

I don't think there is a VM in the mainstream that uses the Data/Return stack Forth architecture but I could be wrong.

I think they all died for different reasons. Forth was trying to solve a problem that no longer really exists (need for a tiny self contained system on novel hardware). This is now C compilers. Lisp I haven't had much to do with but its proponents are their own worst enemies. I did a lot of work with Smalltalk and basically other environments just got better without the problems you get deploying smalltalk images. Nostalgia is fun but things like .NET core are so good now you can build and deploy systems with virtually no friction using whatever paradigm you are comfortable with.

PostScript is a stack based language like Forth but things like NeWS that were based on it never really took off.

Forth doesn't really solve the same problem as C. It's more like a minimal self-contained interpreter/VM, and it can still be useful as such.

The whole HOPL proceedings is worth reading.

Reply on news.ycombinator.com