“Forth is a simple, natural computer language. It has achieved remarkable acceptance where efficiency is valued. It evolved in the 1960s on a journey from university through business to laboratory. This is the story of how a simple interpreter expanded its abilities to become a complete programming language/operating system.”
Forth: the early years
About The Author
Follow me on Twitter @thomholwerda
2013-07-25 11:09 pmbartgrantham
OF was great. The actual implementation of the OF drivers was sometimes suspect, but the ideas behind it really deserved to win and become a widespread standard. Imagine if any OS on any cpu family could enumerate and make basic use of peripherals without having specific drivers for that architecture and platform. Such a shame that it’s ancient history now.
I once read an apocryphal story that the stack-heavy design of the JVM was influenced by the success Sun had with OpenFirmware. It makes some sense that there’d be a thread of design from OF to the JVM.
2013-07-26 7:48 amfithisux
It is really a shame. The lack of proper OS initialization kills the user experience and small OSes. The OF idea should deserve a second look instead of UEFI.
2013-07-26 8:50 pmDrumhellar
UEFI is a second look at the OF idea.
It also implements it’s own processor-independent bytecode format to provide basic graphics and disk services to an OS before the real driver is loaded.
But, it isn’t enough just to offer the functionality. Hardware makers need to use it, and OS devs need to take advantage of it. I don’t know if this is the case,though.
Edited 2013-07-26 20:51 UTC
2013-07-26 8:33 pmDrumhellar
Have Oracle and IBM moved away from it? Or, was it never really updated to work beyond regular PCI? I’m pretty sure it’s used for the OLPC XO.
2013-07-28 10:57 pmrapmaster
Yes, Forth was part of the One Laptop Per Child (OLPC) firmware system. Here’s an interview that illuminates this a bit more: http://howsoftwareisbuilt.com/2008/03/27/interview-with-mitch-bradl…
Also, there are a series of 24 Forth tutorials related to OpenFirmware on the OLPC site: http://wiki.laptop.org/go/Forth_Lessons
Is OLPC dead, or does it just smell funny?
What a Delightful and Charming Article (9 syllables).
Typically when the history of Forth is discussed, it start at NRAO. This insight farther back to the evolution of the system is fascinating.
You can see the actual evolution of the system from a simple command interpreter all the way up to the full blown environment it became as of the late 80’s and early 90’s.
It’s keen insight in to the history of computing from the point of view of simplicity. Chuck Moore isn’t one to brood on abstractions. He uses the system to uplift the environment to his naturally low level way of thinking about machines and computing. His writings on ColorForth and how he applies it to his chip design work is also fascinating.
Many of us are more and more detached and separated from the machines that we run. Today, the computers themselves are abstractions built on other computers. High level environments running in VMs hosted on remote systems. The domains requiring local machines are shrinking every day. So, it’s nice to read something like this and reconnect, if just for a minute, back to the time when every byte and clock cycle mattered.
It also interesting in light of the rise of the low powered machines, and the rise of the hacker/makers excited over blinking LEDs on a micro controller they bought for $1.
Back in the 70’s I had the opportunity to visit Forth Inc (I think it was in Redondo Beach, CA). The company was on the second floor of some building near the beach, and was divided into two enclosed office spaces, separated by an outdoor breezeway. One of the office spaces had all the business people – all dressed in suits. The other office space had all the programmers, dresssed – well, like programmers. The breezeway ensured that they would not come in contact with one another.
A lot of very good work was done using programs coded in Forth. I used it both as a part of a data acquisition system for an instrument I built and also for analysis of the data that it generated.
Oh yes. The best thing about visiting Forth, Inc? You could hang out on the beach at lunchtime.
2013-07-26 6:21 amKochise
Wondering about Lisp as well…
My lecturer at university is or was on the Forth Standards Committee. Never used it myself though.
Adobe PostrScript is inspired by Forth. http://en.wikipedia.org/wiki/PostScript#The_language
2013-07-27 5:58 amtransputer_guy
Just to add a circular note.
As the wikipedia article also states, PS was a successor language to InterPress which itself evolved from JaM used for VLSI layout at Xerox PARC, just as I remembered.
A few years later when I wrote yet another VLSI layout editor for the Mac using C, there was another program called MacGDS written entirely in Forth. This was a Mac work alike of the industry standard Calma GDS II CAD program that usually cost $100k or more running on a Nova/Eclipse minicomputer and used by every chip designer of the day.
Later MacGDS was rewritten in C++ and relabeled dw-2000 and is still around, but even still, the Forth version was pretty darn impressive for such a language.
Also as I recall, the Forth people also got quite involved in chip and processor design of tiny Forth like cores.
In the 80’s, Forth was quite popular. I was really amazed how I could write a complete Forth interpreter in 200 bytes of 6502 assembler. Back then, Forth was cool and C was something a few crazy people up in Boston were playing with.
What few people seem to know is that Forth is only one of a family of Threaded Interpreted Languages. What fewer people know is that the Sinclair ZX series of computers used a TIL to create the tokenized BASIC that could run in 1K of memory.
Still fewer know that the internals of many other BASICs of the 70’s and 80’s were written using a TIL. Just don’t call it Forth because that’s a trademark.
The chief value of Forth is that it “thinks” the same way that processors do, making everything a stack. If you understand the processor, you can write blazingly fast programs in very little space.
Sadly no one needs tiny languages like Forth. But I still miss it. Hmmm …. I wonder if there is a Forth for the Raspberry Pi?
Oh how I miss my Jupiter Ace: https://en.wikipedia.org/wiki/Jupiter_Ace
Still have the manual which I will be happy to donate to an enthusiast or museum.
I think this is the first time I’ve seen Forth mentioned outside of the context of OpenFirmware, which in a lot of ways is still better than UEFI.
Using Forth, an expansion card could provide a basic level of service in firmware at boot time, so an OS (or the OpenFirmware itself) could boot off of or install on to a SCSI card before an optimized driver was loaded, or write text/graphics to a screen in the case of a video card.
Since OF was used quite widely (Sun used it for SPARC, IBM used it for their Power systems, and even Apple used it for their PPC systems), a company could make an expansion card, and it would operate at a basic level for any system using OpenFirmware.
The Forth was compiled into FCode, an interpreted bytecode, and placed on the expansion card’s firmware. This would let an operating system to use the hardware before loading a driver.