Forth Application Techniques

oxgoad writes "Sun Microsystems, Federal Express, the National Radio Astronomy Observatory -- what do they have in common? All have used, or are currently using, the programming language Forth in critical subsystems of their products or processes. 'What is this language Forth?' you ask. Forth has been called 'One of the best-kept secrets in the computing world.' Read on for a review of the book Forth Application Techniques authored by Elizabeth D. Rather." Forth Application Techniques author Elizabeth D. Rather pages 148 publisher Forth, Inc. rating 5 reviewer oxgoad ISBN 0966215613 summary A concise introduction to the Forth programming language.

Who & What

Elizabeth D. Rather, president of Forth, Inc., would appear to be the second Forth programmer in the universe. This distinction came about in 1971 when she was brought in at the Kitt Peak NRAO to maintain code written in a quirky language developed by Chuck Moore. Running on a DDP-116 and a H316, this code was responsible for controlling the telescope, data acquisition, and graphical display. After a few years, Moore and Rather, along with Edward K. Conklin, formed Forth, Inc. to attempt commercialization of the language.

Forth Application Techniques attempts to provide a comprehensive introduction to the language for the neophyte Forth programmer. I would say that it pretty much succeeds as such, quietly plodding away through each primitive and feature. It is written in workbook style with various sample problems for the reader to complete. You might not be a Forth coder after reading the book cover to cover; however, you will have a working knowledge of the language and should be able to walk through legacy code with a minimum of difficulty.

If I might step aside from my role as unbiased book observer for a moment, I would like to make a few comments about the state of programming languages in general. It seems that quite often we take for granted essential, but practically invisible, tradesmen such as plumbers and garbage collectors. (Fire your janitor and your web designer -- guess which one you will miss first. Guess which one will still be employable 15 years from now.) Yet, without their services, our daily quality of life would certainly fail to meet our expectations.

Likewise, Forth seems to be an invisible language. No flash, no e-commerce, and no glamour. Such is the nature of embedded systems -- even though every Federal Express delivery driver carries a Forth-based device on his belt. This appears to have resulted in a dearth of quality books dealing with Forth. Search your favorite online book retailer and note the dozens of Forth books that are no longer in print.

While Scheme is from the ivory tower and Forth might be said to be from the machine shop, they do have something in common that is a possible deterrent to the popularity of Forth. Like Scheme, you either get Forth -- or you don't. Stack-based languages leave some programmers dazed and confused. And, as with most languages, it is possible to write some truly obfuscated code. Any language that will allow you to define the number 4 as a word that places the number 3 on the stack can be a frightening weapon in the hands of the contrary.

Kudos

Forth Application Techniques can be commended on its consistency. Careful attention has been given to typefaces to distinguish interpreter output from user input. All primitives and defined words are covered in a clear and unambiguous manner. The book is spiral bound in a plastic binding, and this lay-flat binding is great when using it at your computer or while eating lunch.

Quibbles

The same lay-flat spiral binding that is such a boon when working at the computer can be somewhat of a nuisance when when attempting to hand-hold the book -- the book tends to flop about and feels very insubstantial.

While Forth Application Techniques is very complete and accurate, it is also extremely passionless. You might compare it to a biology textbook discussion of sexual reproduction with no mention of romance. There is no discussion or examples of using Forth in ways that will bring enlightenment. To be fair, in the preface it states that the purpose of the book is to support Forth classes taught at Forth, Inc. This is something that is not entirely clear when examining online retailers' display of the book.

Also of note is that there are occasional features specific to Forth Inc.'s SwiftForth product documented in the book. I would not consider this a real issue as all instances are clearly denoted with an icon. With the exception of chapter 9, which is entirely Forth Inc. specific, the readability is not affected in any way.

Crimes

Forth Application Techniques has no index. With its workbook styling, most will not consider this to be a tragedy. All the same, it would be convenient to look up primitives and defined words.

Conclusions

Should you buy this book? That depends on your desired end result. It is adequate for a quick introduction to Forth. If you are intending to write production code I believe Forth Programmer's Handbook (from the same publisher, review forthcoming) would be a better choice. If possible, I would supplement either with a used copy of Leo Brodie's Starting Forth -- an out-of-print classic.

Where I foresee this book to be a great benefit is in ordering a half-dozen copies for your programming team prior to taking on a legacy project or when considering Forth as a new development platform. The members of your team that "get it" can then enlighten the others with this invisible language.

Table of Contents

• Preface: About This Book

1. Introduction
2. Simple Forth Primitives
3. Structured Programming In Forth
4. Data Storage
5. Strings And Characters
6. Number Conversion
7. Vectored Execution
8. Advanced Concepts
9. Multitasking
10. Style Recommendations

Disclosure

I received a review copy of this book from the publisher. Thus, my loyalties and opinions may be completely skewed. Caveat Lector.

Forth Application Techniques is available from Forth, Inc. and from some online merchants like Amazon. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Comments

So two of us own that book :-)

[redbaron7]

I bought this book a couple of years ago, when I had an idea for a project which I thought could benefit from a Forth-style system. In those days I did a lot more at-home dabbling which I just don't have time for now, and that idea has gone by the wayside.

If you have any questions for Elizabeth Rather, she can be found on Usenet. When I asked for an "introductory book for modern Forth" I believe she recommended her own book! :-)

Threaded Interpretive Languages (TILs) such as Forth have very elegant inner workings. I even wrote one as a kid. And I actually used it for a few months. Although my Forth-inspired TIL was limited to 16 bit integer math (on an 8086 I think it was), I still managed to get it to draw 3d wireframe graphics in real time on a PLUTO graphics card :-)

RB

No Thanks

[acehole]

Until I see a decent Language to switch to I'll stick to my punchcards.

Jupiter Ace

[PHAEDRU5]

Back in the days of yore, when the world was still mostly in black and white, and strange man-eating beasts wandered the land, a small British company brought out a cute little computer called the Jupiter Ace.

It was basically a Sinclair ZX-80, but with Forth in ROM, instead of BASIC. It was a fun little thing to play with.

I may still have mine in a box in the attic. Must go check.

Forth is alive every time you print

[LineGrunt]

Postscript is based on Forth. You can "program" Postscript...

Don't know why a non-printer driver person would want to, but you can...

-LG

Re:Forth is alive every time you print

[xmath]

For some boring stats course we had a programming assignment "in a programming language of your choice".... big mistake

since it was basically a simple statistical experiment + graphical output, I wrote it in PostScript.

Kinda cool, it was a report with the statistical experiments embedded, so if you printed it twice, all the graphs were different :-)

Re:Forth is alive every time you print

[bunratty]

Postscript is based on Forth. You can "program" Postscript...

Don't know why a non-printer driver person would want to, but you can...

Using PostScript you can send a very small text file to the printer and have it print some amazing graphics. I used it years ago to draw dragon curves (a type of fractal), charts, and text that followed a wavy line for a poster.

PostScript isn't really based on Forth. It's just another stack-based language, as is the language used for HP calculators, and virtual machines such as Java bytecode and .Net CIL.

Re:Forth is alive every time you print

[unfortunateson]

% Save this as dragon.ps for 15 pages of
% fractal iteration -- commented even!
% define constant of 1/sqrt(2)
/Scalefactor 1 2 sqrt div def

% Define Fractal subroutine
% usage: lvl Fractal stroke
% Examples below are as if called with a level of 5
/Fractal { % 5
dup % 5 5
0 eq % 5 false
{
% True condition: draws line segment
pop 300 0 rlineto % -
}
{
% False condition: recurse routine
% set the scale factor
Scalefactor dup scale % 5
% On alternate iterations, level is set negative. When negative, reverse the angles
dup -90 exch % 5 -90 5
0 lt % 5 -90 false
{ neg exch neg exch } if % 5 -90 false
% Recurse one level lower
dup 2 div % 5 -90 -45
rotate exch 1 sub % -90 4
% Actually call myself again
dup Fractal % -90 4
exch dup neg % 4 -90 90
rotate exch neg % -90 -4
% Call second time for second stroke
Fractal % -90
2 div % -45
% set things back to the original scale and rotation
rotate % -
1 Scalefactor div dup scale % -
}
ifelse
} bind def

% Loop to iterate 15 pages of fractal
currentlinewidth 4 div setlinewidth
0 1 15 { 200 400 moveto Fractal stroke showpage } for

Ah this is great!

[TerryAtWork]

FORTH is an incredible language!

I ran Miller Microcomputer Forth on a TRS-80 back in the day and it was amazing.

Forth is totally stack oriented. It is difficult to determine where the OS ends and the language begins.

It is naturally recursive.

DONE RIGHT you can do a LOT in a few lines.

You can shoot yourself in the BULLET with Forth.

And Spiderman would code in Forth because...

Re:Ah this is great!

[wkitchen]

Forth is totally stack oriented. It is difficult to determine where the OS ends and the language begins.

Operating systems are for wimps.

Those old enough to remember early 8-bit home computers like the C64, TI99, and similar, may recall that many of these "booted" straight into a BASIC editor/interpreter that was stored in ROM. Nothing between you and the hardware except for this and some very low level rom code roughly equivalent to a BIOS. A VERY low-fat system. Compare that to the multiple levels of abstraction and bloat we have now.

Ever think it might be sort of cool to run that kind of low-fat system on powerful modern hardware? Sort of like an ultimate C64 with, hundreds of megabytes of RAM, and many hundreds of MIPS. Maybe not pretty, but the raw computing horsepower at your fingertips would be awesome, provided you know the system well enough to use it. Replace that BASIC interpreter with the close-to-the-machine spartan efficiency of Forth, and it gets even leaner and meaner.

Chuck Moore, the inventor of Forth, has created an interesting little critter called colorForth that does just this. Stick the floppy in the drive, turn on the power, and boot straight into colorForth. The system is at your command. No OS, other than colorForth itself. The most bloated piece of software on the machine is the BIOS.

Just you. In complete control of your machine. What a concept.

"best kept secret"

[extremely]

"Best kept secret" is actually a review for Forth, not the problem. If I'm going to have to deal with a stack, it should have butter and syrup on it.

Still Worth Learning

[Anonymous Coward]

Forth is still great when resources are very limited... Palm OS programming, for instance. I've used it there and in several embedded systems projects without an underlying OS, and managed to run circles around a team coding for 8051-based systems in PL/M (I think that's the name of what they were using, but I'm not 100% certain).

I also tried a version of Forth-83 for Windows by Ray Duncan's company, LMI. I tried to code up a DDE server, and while it worked, it was painful. I've come to believe that Forth is more trouble than its worth when interfacing to APIs designed for C. Such APIs are often poorly factored (relative to how you'd solve a problem in Forth), and take too many parameters of different sizes as arguments. Even with the Palm you jump through some of these hoops, but in that environment it's often worth the effort.

The underlying principles of Forth are worth knowing no matter what language you program in... there's a lot of simplicity at its core, and it'll help you understand how to program for other stack based languages such as .NET's CIL. And nothing I've seen teaches factoring better than Forth (too bad Brodie's "Thinking Forth" is out of print).

Re:Still Worth Learning

[Waffle Iron]

It's also worth learning just because it's one of the few languages that is simple enough that you can actually understand the implementation top-to-bottom. You could write a simple Forth interpreter in assembly language in a couple of days, just to educate yourself on how languages work. (I did this once for 16-bit X86s about 15 years ago).

Forth is also an excellent example of "emergent behavior". Even though the language implementation is simple, the dynamic behavior can quickly becom mind blowing. I still have a hard time completely understanding the way some of the compiling "words" (which dynamically add syntax to the language similar to Lisp macros) work in Forth.

If nothing else, Forth will teach you to factor your code into small procdures, because making a function longer than about 5 lines quickly becomes unreadable :).

Open Firmware

[Mikey-San]

Forth is still in heavy use, actually, as the language for Apple's Open Firmware (IEEE-1275) implementation:

http://developer.apple.com/hardware/pci/

Oh, huh? I was supposed to make a point? Whoops. :-)

-/-
Mikey-San

Re:Open Firmware

[Draoi]

Here's the official site & here's Sun's lesser-known public OF site ....

and also

[mirko]

Sun Microsystems, Federal Express, the National Radio Astronomy Observatory -- what do they have in common? All have used, or are currently using, the programming language Forth in critical subsystems of their products or processes."

And also Adobe who really got inspired for this when designing the Postscript language too...

Concerning Sun there have been at least 2 uses :
1) for their boot manager
2) for the Java Virtual Manager which is a stack language based-environment.

Re:the inevitabele Forth/Jupiter Ace comment

[rmolehusband]

OK, so things are sluggish at work.

A quick trawl came up with the following 'Nix based
emulator

Apple too.

[ZigMonty]

Apple's OpenFirmware also uses forth. Hold down Command+Option+o+f at startup and you are thrown into a Forth shell. How's that for a BIOS?

Re:What they have in common

[cduffy]

It's entirely possible to make money working on free software -- that's what I've done for the last two years.

That said, the parent poster is indeed an idiot. Much commercial software is worth buying, and not all products can be economically written and supported as open source.

Incidentally, I interpreted the "give you nothing in return" thing a bit differently wrt Sun -- their machines really don't have the same value proposition as many others (Intel-based systems on the low end, IBM's big iron on the high end), and I took the (great?) grandparent to be painting a somewhat exagerated carciature of that.

Elizabeth Rather

[Draoi]

I had the honour to meet Elizabeth at Apple during an OpenFirmware/FCode training course. She's an amazing teacher & is one of the first people ever to use the language, having worked with Chuck Moore in the late 60s ....

She now works with Forth, Inc. Check out forth.com. They have an excellent history of the language here. BTW, there are free Forth interpreters for just about every platform out there. It's a cool language.

Chuck Moore's own site is here

Re:Religious experience to "get Forth"?

[Anonymous Coward]

Once you understand how to use the CREATE/DOES> construct effectively, you have a great deal of flexibility in expressing a programming solution. Most languages allow you to add new functions; Forth allows you to extend the compiler, using whatever syntax your imagination can conjure up --- one tailored exclusively for solving the problem at hand.

This power is often what someone refers to when they talk about "getting" it. Forth has also been criticized by some, ironically for that very strength. Why?

At the high levels of your application, you're no longer coding in Forth, but in the language you've designed to solve the problem. Reading that code requires a newcomer to understand that new language, in much more depth than they'd need for something like a C program. When designed by a competent Forth programmer, this code can be quite readable, at least in a general sense, by anyone who understands the problem domain. But a novice Forth programmer, particularly one who thinks in terms of writing a program in Forth (rather than extending Forth to solve the problem), can create a very unreadable mess.

With power comes responsibility (a phrase that predates Spider-Man, by the way :). Forth has no training wheels, but once learned, it is a very useful tool. "Getting it" is worth the effort.

Modern Forths are compiled, not interpreted

[Junks Jerzey]

I keep seeing mentions of Forth being an interpreted language, but that's just an implementation choice. Most modern Forths, such as iForth, VFX Forth, and Forth Inc's own SwiftForth, generate machine code and do optimization to varying degrees. iForth and VFX Forth analyze stack operations and replace them with register operations where possible. Benchmarks have shown that iForth generates better floating point code than Microsoft's Visual C++ compiler (which already generates better floating point code than gcc).

So why don't you hear about Forth much? A couple of reasons:

1. Forth doesn't have much in the way of standard libraries, so you'll almost certainly get more bang for your time writing quickie applications in Perl or Python than Forth. Try writing a Forth program to read in a file of strings of arbitrary length and sort them, for example. This is a one liner in Perl.

2. Forth has always been geared toward simplicity, but modern desktop environments (Linux, Windows, MacOS) are hugely complex. Forth arguably isn't the best match for such complexity. Embedded systems are different.

3. Forth is best viewed as an interactive alternative to C or assembly language. Certainly from the interactivity alone Forth is a better choice for incrementally building a application than assembly language. This is why Forth gets a lot of use in embedded systems. But with desktop computer speeds being insanely high, it's hard to justify working on that kind of level under, say, Linux or Windows.

(I fully expect this to be followed by "Not true!" rantings from a Forth zealot or two. But you really do have a hard time pointing to compelling applications written in Forth for modern desktop OSes. Python is a good language, so you see some amazing applications written in it (e.g. Zope), but despite all the religion surrounding Forth, you never see much to show for it on the desktop.)

Re:definitions of species

[Bazzargh]

Er, I did.

Back in the day (crikey was that really 8 years ago???) I wrote PSTab, a guitar tablature typesetter, in postscript. I'd been downloading tab for songs from the (defunct?) OLGA, and wanted to print some for use at home. However, ascii tab looked crap and took lots of space on the page; if you tried to shrink it to use less paper it just left blank space at the sides.

We had an old Apple II laserwriter on the corridor, and I had written simple EPS diagramming tools for my thesis in awk (copy and paste programming)... so armed with borrowed copies of the red, green & blue books, I learned PS properly and wrote a typesetter that you could use as a header on simple input files (I'd spotted this was how the windows PS driver worked). Once I got to the stage I could wrap ascii-tab up to make *nice* output pages my itch was scratched[1].

Best thing about it was getting an email from a guy in NZ who used it to produce camera-ready copy for a book of banjo music - there wasnt anything else out there that could handle 5-stringed instruments :) . And that the unplayable example song getting a life of its own in the GuitarTeX manual!

-Baz

[1] I know there are bugs. Some of these didnt show up until I saw the output on a higher quality printer. Bah.

[Old Fogey Warning] I programmed in Forth once...

[Jack William Bell]

... And I certainly remember the joke about how in Forth you "Foot in yourself shoot."

I did my Forthing many years ago (far, far too many). The usual thing, embedded systems work, but I actually did the programming on an IBM PC (original) using a Forth boot floppy (it had its own environment/OS). Then someone else did integration with the embedded system.

It was a truly weird language, and it made it far too easy to create 'write-once' unmaintainable code. But it was my first introduction to many concepts, including a language that was truly 'cross-platform'. And it led to a short job at Aldus because I already understood stack-based languages, so Postscript wasn't a shock to me.

In many ways Charles Moore is a seriously twisted genious. I have always rooted for him, despite the fact I prefer to use a cleaner, more readable language. (Can we say 'Python'? I knew we could.)

So, in the end, I cannot say I think Forth should be in everyone's toolkit. For that reason I expect this review will be of limited use to most of us. (Attn. Moderators, notice how I managed to get this post on-topic in the last sentence. Now you have to mod me down as 'flamebait' or 'boring' or something.)

Jack William Bell

url for colorForth

[wkitchen]

Chuck Moore's home page:

http://www.colorforth.com

Re:Computer languages are all the same

[AB3A]

Let me guess: fasteners are all the same, so let's use a hammer to pound in a screw.

Most languages have a focus toward a particular aspect of programming. Some are very good for Object orientation. Some are good for low level hardware I/O. Some are designed to parse input in optimal fashion. Others are designed for terse code.

They all have a purpose. That's why we have software tool chests with lots of languages and tools which can be used in so many ways.

Forth is good for low level I/O work. It's often used in Robotics and control systems. It is a minimalist language and it generates very fast, memory efficient code. These are good traits when dealing with embedded processors. But once you try scaling it up to do more complex tasks, you discover its limitations. That's when higher level languages start to shine.

Starting Forth is a Must!

[farrellj]

Leo Brodie's is one of the best books to learn Forth with. And the cartoons in it are the funniest/best in a manual that I have seen since the first Wizardry Manual!

ttyl
Farrell

Fabulous language, but for an uncommon situation

[dwheeler]

FORTH is truly a fabulous language when you need to be able to interactively develop a program, where both the programming and execution must run on a very tiny machine (e.g., 2-48K RAM and 1-10MHz), and you still need the program to run quickly. Not only can you write code quickly, and get lots of interaction, but many Forth implementations are extraordinarily small, so you can actually read _every_ line of machine/assemly code that's executed on your equipment if you need to. I remember some absolutely magical programs being written on Apple II and Atari 800 computers (32-64K RAM, 1MHz 6502 chips).

The problem is, the situation that FORTH is great in is becoming increasingly rare. Most FORTHs still require programmers to constantly think about how to juggle the stack if they receive a number of parameters (yes, there are some extensions). FORTH has essentially no type-checking, and the combination of these two factors means that it's extremely easy to (1) make a mistake and (2) for that mistake to have nasty consequences.

Many program language implementations generate intermediate stack-based code (think Java class files, Python, Perl, etc.); in FORTH, you're writing the stack-based code yourself, so you are essentially writing in an assembly language for a simulated stack-based system. FORTH thus has some of the similar properties as assembler: fewer development system resources are required, but it's more work for the programmer. This isn't completely true; FORTH is definitely much higher-level than the typical assembly language program, but many programs take more work to implement in FORTH than, say, Python (which is also interactive, and it executes a stack-based program, but lets people express code in a more Algol-like way and then TRANSLATES that code into a stack-based approach).

I do think Forth is a good language to learn, because many systems are built on stack-based intermediate languages (Java, C#, Perl, Python), and being able to directly interact with a stack-based language helps to learn how they really work.

An implementation of Forth for 6502 is freely available.

Groking Forth and stuff

[oldstrat]

Once apon a time the first language for any new machine was Forth. But then again it's been a long time since we've seen any really new machines.

The reviewer is correct, someone groks forth or they don't.
Being a person who groked it from the second he saw it in 1978, I can't understand anyone not getting it.
Sure RPN notation is hard for some (apparently most) folks, and boolean logic just doesn't seem to be natural for most people, and then the stack just knocks them in the head, but these are three of the four pillars of what makes forth great.
The fourth pillar of forth is that you can change it to be anything you want, most languages have to be learned, forth is a language that you can teach to learn you... If RPN is just intolerable you could redefine it and still leave the core alone for pre existing words (functions for the non forth crowd).

Leo Brodie's "Starting Forth" and "Thinking Forth" books are great and it's a shame that Brodie no longer has an interest in the language.

As a long time forth user I'm not thrilled with the complexity added in C. Moore's latest version colorForth, it seems to add a new layer of complexity, but then again I may just be unable to Grok it.

Personally I'd love to see Forth brought to the GUI era and don't understand why it hasn't been.

Display Forth?

[zatz]

I find it interesting that so many people comment that Forth is meant for embedded environments and has no place in a "modern" GUI system. But PostScript is similar to Forth in flavor, and its original embedded target was printers... and now OS X uses "Display PDF", more or less a superset of Display PostScript.

Just because a tool like Forth is traditionally used by a single programmer in a very cramped system doesn't mean it couldn't have applications in other places. There are many things I wouldn't write in Forth... and there are many times I find myself writing GDI calls and wishing for a more Forth-like interface.