Slashdot Mirror
Forth Application Techniques
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.
KudosForth 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.
QuibblesThe 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.
CrimesForth 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.
ConclusionsShould 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
- Introduction
- Simple Forth Primitives
- Structured Programming In Forth
- Data Storage
- Strings And Characters
- Number Conversion
- Vectored Execution
- Advanced Concepts
- Multitasking
- Style Recommendations
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.
Sun Microsystems, Federal Express, the National Radio Astronomy Observatory -- what do they have in common?
They all take our money and give us nothing in return?
---
Hello, Slashdot user. My name is Dr. Sbaitso. I am here to help you.
Jeez, I can remember having a Forth compiler for my Commodore 64!!!!
I had heard that Sun use forth for their OpenBoot proms...
Not that forth is dead by any means, but it has sort of lapsed into obscurity.
:)
Nice to see recent development is still happening,
as forth always has been the best for what its designed for, controlling stuff. Probably always will.
Plus its sooo cool
---- Booth was a patriot ----
Every time I read about Forth it takes me back, I had a Jupiter Ace as a kid. Sad to say that it was easier to get my ZX81 to do cool stuff so it got kind of neglected. Shame.
Maybe it's time to google up an emulator and indulge in a bit of notsalgia.
Reginald Molehusband. Edinburgh, Scotland
This was my first home computer - and it ran Forth. I won it in a competition in Popular Computing Weekly back in 1982. I never quite figured out how to program it, because my ZX-Spectrum 48k arrived the next day. Maybe if my sinclair had been delayed I would have taken the time learning how to write Forth, and perhaps by now I could have programmed my own Radio Telescope (which has to be the ultimate way to cheat at SETI@home) :-)
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
Yes, indeed.
And that's why you can't use commodity SCSI cards in Sun architecture. The stupid OpenBoot expects to find Forth interpreter on the card which only the high end, Sun approved cards have.
Until I see a decent Language to switch to I'll stick to my punchcards.
Be you Admins? nay, we are but lusers!
Try fourth post.
slashdot!=valid HTML
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.
668: Neighbour of the Beast
review forthcoming, eh? what a mad little punster you are. ;)
Apple uses a variant of OpenBoot called Open Firmware for all power macs released since the 7200/75. It, too, runs off of f-code.
Could someone tell me why I can't post from home? I'm going through anonymizer here. Did some moron at Slashdot ban everyone?
BTW: If some retard moderates this offtopic, how about you take a look at the tiny number of posts...there's a reason.
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
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...
It's Christmas everyday with BitTorrent.
"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.
$you = new YOU;
honk() if $you->love(perl)
Fortran used to let you do that, but usually by accident.
Parameters were *always* passed by reference (var in pascal or & in C++), so you couldn't pass a number constant. Compilers would create a table of constant values, though, and pass the address into the table. However, if the function modified the value, it modified the number "constant" entry in the table.
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).
.NET's CIL. And nothing I've seen teaches factoring better than Forth (too bad Brodie's "Thinking Forth" is out of print).
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
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
Mikey-San
Karma: +Eleventy billion (mostly affected by watching Celebrity Jeopardy)
...unfortunately, it's got it's own acronym, MUF, short for Multi User Forth. It's used on a sub-set of on-line Multi User Dungeons known as MUCK's, specifically all those based on the FuzzBall variant, which at this point includes a couple of notable ones such as ProtoMUCK.
As a quick pair of references, check out the ProtoMUCK and FBMuck projects on SourceForge.
Trolling using another account since 2005.
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?
I just went through amazon.com web site and I regret that most (if not all) Forth books written by Leo Brodie are out of stock...
I remember waiting until 4 months to get a copy of "thinking forth", by the way.
Now, if you want to learn forth, there seem to be the gforth manual, at least...
Trolling using another account since 2005.
yea, FORTH is so neat and easy to use...
Wanting to wear diapers has nothing to do with sex. It may turn you on, but that's not bad.
Does anyone remember using NEON, an "object-oriented FORTH" for the Macintosh? I remember using that back in 1985 for a professor at Swarthmore College...back when it was actually a pretty fantastic programming environment for the Classic Macs.
(This was at the very beginning of SANE too, and NEON didn't have any native fp code, so we had to hack that in in 68030 assembler. What fun!)
I am the Lorvax, I speak for the machines.
Greetings of the day.
I accept this honor with solemnity and indemnity.
I used to have a Forth compiler for my ZX Spectrum.
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.
Hmm... If I remember correctly, early versions of FORTRAN allowed you to redefine TRUE and FALSE. Can you still do that?
Cress, cress, lovely lovely cress
Some of Moore's trial runs for Forth ran on Burroughs mainframes and were actually implemented as card decks.
In the late '80s, there was a sweet Forth implementation for the Mac called Mach 2. It produced native 68000 code -- unusual because most Forths produced an interpreted byte-code, but possible because of the 68000's stack orientation -- and was cheap (about $50).
While it wasn't the easiest thing in the world to use for building complete GUI apps, it was a great experimental tool because it was essentially an interpreted assembler/disassembler! You could experiment with OS traps that were recently published but hadn't made it to other compiler implementations, and see what machine opcodes would do the job minimally.
You could then take those opcodes and drop them into, say Turbo Pascal (which was barely supported by Borland) as inline machine instructions. Way cool.
The other place where Forth came in handy was a couple several years later when learning PostScript: as a stack-based language, PostScript was a cinch to pick up. Of course, if you've been using RPN calculators, it shouldn't be too bad either.
Forth may be a little low-level in these days when Perl and Python provide such abstract data types, but it makes you think closer to the hardware. When hardware control is an issue (in devices like telescopes, barcode readers, etc.), Forth beats programming in assembler by a long shot.
Design for Use, not Construction!
... on a Commodore 64 and an early Mac. At the time, it was the only "PC" language I was truly productive with.
I remember writing an application I could use to program sheet music to be played by the 64's sound chip. I simply specified a voice, a note value, and a note duration (e.g., quarter note, half note, etc.) for each note in succession. I demonstrated it to my local Commodore users group and it got ooh's and ah's.
I also have a copy of the mentioned book by Leo Brodie.
Tim
I almost bought a microprocessor running Forth recently, but I couldn't pull the trigger (IsoPod). I used Forth many years ago, and it seemed cool, but the problem I have with it is still there... even in this review, everyone always says Forth is great for embedded apps, but it can never be explained in a way that speaks to my inner geek.
I just can't buy that you need to have a religious experience in order to understand why a language has benefits.
-Shane
I love teh int4rw3b!!!!!111one1
Hey, you just rebooted my machine ...
HI and HELLO in forth (depending on flavor) reboot.
Can't wait to get my hands on the new book, we are heavy forth users.
TastesLikeHerringFlavoredChicken
Sometimes children are interested in toilet training, but not exactly ready emotionally. Try to find out what she doesn't like about the potty. It may be nothing more than unreadiness. She may have worries about something you can explain, such as where her bowel movement goes after the toilet is flushed.
At any rate, be patient. She will train again! The easier the experience, the fewer accidents she will have later on. Many children, especially those who are attempting early training, regress for a time but train quickly when they are ready.
>> I just can't buy that you need to have a religious experience in order to understand why a language has benefits.
So, you've probably never tried Smalltalk, either?
An Eight-Instruction Turing-Complete Programming Language
set/read variables
conditional, branching and looping constructs
call functions
I see very little difference between:
Lisp/Scheme's
(my_function (+ a b))
C/C++/C#/Java/Javascript's
my_function(a + b);
Forth/Postscript/other postfix languages
a b + my_function
or assembler:
push a
push b
add
jsr my_function
It just boils down to syntax and ease of typing.
It's interesting to note that C-style syntax seems to have won the popularity contest, though. Code is written in any of PHP, Perl, C, C++, Objective C, C#, Java, Javascript are easily understood by anyone versed in any language in the set.
Most languages are stack based, but a few like Lisp and Javascript support the notion of closures. But even closures can be emulated in C of course via heap allocated memory and function objects. Indeed, you can emulate any computer language construct in any other computer language (with varying degrees of efficiency, of course).
In the end, the computer language is usually chosen based on:
popularity (because this implies support for the language and longevity for your system)
ease of coding
execution speed
Too bad there does not exist a universal computer language compiler system whereby one could code in the computer language they prefer and check the code in and the next guy could check out the code in the language they prefer.
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
Alison
"It is a miracle that curiosity survives formal education." - Albert Einstein
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.
:). Forth has no training wheels, but once learned, it is a very useful tool. "Getting it" is worth the effort.
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
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.)
Er, I did.
:) . And that the unplayable example song getting a life of its own in the GuitarTeX manual!
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
-Baz
[1] I know there are bugs. Some of these didnt show up until I saw the output on a higher quality printer. Bah.
... 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
- -
Are you an SF Fan? Are you a Tru-Fan?
If you want to fool around with FORTH
on your own and for free, take a look at
Phil Burk's
public domain pForth
Wait a minute. Didn't I say that on the other side of the record? I'd better check
Chuck Moore's home page:
http://www.colorforth.com
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
CAN-CON 2019 - Ottawa's only book oriented Science Fiction Convention! October 18-20, Sheraton Hotel, Ottawa, Canada h
Just my thoughts on the matter, having written many thousands of lines of Forth in the 80s. The current language trends are towards strongly typed languages, with good compile time static verification. Examples of this would be Java or C++.
Forth, like assembler, requires the programmer to manage the stack explicitly. This gives you tremendous power, especially when it comes to shooting yourself in the foot. The level of discipline needed in a multi-programmer team to generate a large project in Forth is much greater than it is with most languages.
Example: A minor change to a word (a subroutine or compiler definition in Forth) can easily cause a stack effect error, by either consuming too many items from the stack, or too few. This probably won't break the code (crash) at the point the error was made, but generates bad parameters for all of the code that executes from that point forward, potentially causing an actual crash at a point in the code far removed from where the error is. Debugging this kind of stack problem is a real nightmare.
Having said all that, I loved writing routines to test new hardware in Forth, because I could interactively code and test. This made me very productive in this limited case.
As you can tell from my handle, I do mainly Java now, and feel it is a much better choice for most projects.
FORTH IF HONK THEN
Did anyone own one of these? It was a wacky ZX81-like computer with a membrane keyboard and 4k. of memory. Instead of programming in BASIC you wrote in Forth. Needless to say it didn't catch on!
Who recalls the 1-2-3 clone VP-Planner from Paperback Software? At the time it was reputed to be the largest and most successful commercial Forth project on the PC. By a bunch of guys from B.C., if I recall correctly. Very cool and memory efficient tool with nifty features. Too bad Lotus litigated them out of existence with the look/feel case...
then thrust your pelvis and hoot
Let me rise to the challenge (and probably crash badly while trying..)
Forth rocks for embedded apps because:
There's probably other reasons why Forth rocks, but that's all I could think of. FWIW, Forth was my third language (right behind Basic and UCSD Pascal) on my trusty old Apple II. Byte magazine did a feature on threaded languages in (August?) 1979, and that really piqued my interest in the language. I did some pretty cool stuff with it on my old Apple, but I haven't touched it in years. But given the compact size of a Forth system, I'd say there's a stong case for considering it when building apps that require some sort of embedded scripting language.
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.
- David A. Wheeler (see my Secure Programming HOWTO)
1. Code in Forth
2. ???
3. Get a lot of chicks who want to have sex with you
I acutally used this language to implement a binary search tree. As you might have guessed, I had to traverse Back and Forth...
Most people who were weened on HP RPN calculators like Forth's postfix notation. I find it a bit unnatural but I was a FORTRAN man for a long time.
"player 4 hit player 1 with 0 stroms"
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.
As you point out, Forth is not a language for writing GUI applications. It's for things like controlling stepper motors in telescopes. It's an embedded systems language for low-level machine conrol. And for those purposes, it's superb.
I, for one, appreciate its simplicity. The modern C/C++ implementations make my head hurt. I don't want a language where there are countless libraries with which I have to remain familiar. It's astounding to see how many C/C++ programmers believe that various Borland/Microsoft libraries are an inherent part of the language.
Yay forth! Yay forth! Rah! Rah! Rah!
u k.org/
Chuck Moore! Woo-hoo!
Elizabeth Rather! Woo-hoo!
Jeff Fox! Woo-hoo!
C. H. Ting! Woo-hoo!
Skip Carter! Yer doggin' it, dude!
Best fan sites:
http://www.forth.org.ru/
http://www.fig-
I wouldn't know old chap.
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.
Or maybe it was URTH, which I think stood for University of Rochester forTH. I seem to remember using this language once upon a time as a co-op back in about 1982, but the net, even Google, seems to retain little memory of it. I say "seem" to remember because I can't recall which exact FORTH or FORTH-like language we used, but I'd like to know because I'd like to find a similar version.
--Jim
Do a search for YERK- it's an OOP implementation based on NEON, and it's sorta open source. More like, not really licensed.
It's been updated for PowerPC, and has some pretty good documentation.
Anyone remember the book 'Thinking Forth'?
Why not use Forth-ran? It's 'Fortran' with a 'Lisp'!
Used mostly for teaching AI, it has a lot of weird features. It also let programmers to manipulate the stack. The VM, called "poplog", supports multilanguage (.net invented 20 years ago) with ML + Prolog + Pop-11 + Lisp implementations off the box, and allows incremental compilation (very similar to CMUCL).
Here you will find an online primer. Another good site.
The Lisp and C styles are based on expressions to be evaluated. Their natural mode is to operate on multiple input values to produce a single output value. Workarounds, to handle multiple outputs, always feel clumsy, and generally require creating more named temporary variables. Furthermore, people naturally have a bias towards this preference, and consider it poor style to modify the machine state mid-expression (regardless of how efficient this is), preferring only to assign the result.
The Forth style is different. Each token is an instruction to be executed in strict order, and performs its function by modifying the machine state in some way. You don't tell the machine, "I want you to find the answer to this problem," you tell it "do this, then that, next this," and in this way you get to know exactly what it's doing. "Returning" multiple values, or making multiple changes to the machine state, is easy and natural. You don't have to put in silly kludges where your return result is a proper answer in some cases and an error code in others, or resort to the absurd COMEFROM of exception handling. There is no limiting syntax to trip over, your own constructs can be as expressive as the ones that are built in.
You don't need to understand algebra to learn Forth. As Chuck Moore says, it should be taught some time after counting and before long division.
In short, Forth is the truly general purpose programming style. It's based on the way computers really work, not some idealized model of how we'd like computers to work. This makes some things a little harder, and makes some things much, much easier.
That said, I don't use Forth much. Everybody uses C, or C-based tools. All the system interfaces are designed and documented for C programmers, and if you want to use them, you have to deal with the workarounds for C's shortcomings regardless of what you actually use. Since interfacing with system libraries is often the biggest and most painful part of a project, this negates the advantage of moving to Forth. Even the processors are designed for C code. Stack machines aren't any less efficient than register machines, but by the time you take advantage of a large register file, your beautifully-simple Forth compiler/interpreter is as monstrous as a C compiler.
Compromise systems, such as ANS Forth, neatly combine the disadvantages of C with the disadvantages of Forth.
And so, Forth ends up restricted to situations where you'd have to build up the kruft yourself if you wanted to use C. Still, I want a T-shirt that says, "I'd rather be programming in Forth!"
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.
Java: the COBOL of the new millenium.
In fact - any modifications to the Open Firmware variables will require a minimal understanding of Forth.
Some reference documents:
Apple Tech Note TN1061 - Fundamentals of Open Firmware: Part 1
Apple Tech Note TN1062 - Fundamentals of Open Firmware: Part 2
NetBSD MacPPC FAQ:What is Open Firmware?
I humbly await your "PyForth" module. :-)
I am doing a project now with an old-school forth guy. Reading the Forth code is a blast- I learned python as my first language and Forth has immediately put me back on training wheels!
One odd thing about this project: it seems that a couple of us are former english majors. I can see Python appealing to a poet who likes villenelles and cestinas... I guess Forth is more like blank verse written by Spider Robinson on a punning tear.
I used to work for a company that deals with real time equity market data web sites: all runs on a custom Forth back end and web application server. CNBC ran on Forth for a year. Fortune Investor, Citibank, American Expresss -- all ran on Forth. www.wallstreetcity.com -- still running on Forth. Reason
I remember that artical in Byte. I never did get Forth for my Apple II. I'm glad I'm not the only one reading /. that remembers thous days!
I can't believe no one has mentioned the Forth bumper sticker:
FORTH YOU LOVE IF HONK THEN
--Curtis
I programmed in Forth for an embedded system used on a factory production line to detect crooked labels of bottle of liquid detergent. Ever since then I've thought of it as write-only language. Looking at the source code 6 months after the project end, I felt as if I were reading Greek. Even when writing Forth, I always kept a stack diagram next to each page of source so I could visualize the stack. Never again.
I remember playing around with and really digging a variation of Forth that I think Paul Lutus(?) wrote called GraForth for the Apple ][ - it was pretty damned powerful. You could create and manipulate 3D objects really simply and do things in hires that were near impossible any other way. Built-in math functions, all the standard conditionals, etc. I remember writing a rather crude flight simulator in it that required very little graphical nuts and bolts type of coding. Wish I knew what happened to that. It was around the time that Logo was being pushed pretty hard, but Forth, syntax-wise, kicked its butt. Maybe it's time to look at it again, reverse notation and all...
"Look, Smithers! I'm Davy Crockett!"
Anyone using the linux/ppc openfirmware bootloader is using a nice little forth program, makes dual or more booting a piece of cake. A while back someone turned an openfirmware equipped Mac into a pong machine.
:)
http://members.aol.com/plforth/ofpong
I've added this to my openfirmware boot target and can boot right into pong
Unix, an obscure operating system developed by bored researchers in an attempt to get a better game playing experience.
The thing about FORTH is that it teaches you to think differently. It shares some properties with assembler; no type casting for a start. You don't actually write programmes in FORTH, you modify the language to suit your needs. It also tends to have some nifty properties like co-operative multi-tasking and really easy ways to integrate assmebler. after all they're both stack based.
I wrote the software for my Bachelor's project in FORTH, a control system for the lifts in my department. The thing ran four separate threads to do create the traffic (from a file), control the lifts and display the current status. It was only a few hundred lines of code.
You're not alone - I got a FORTH like system going on an Altair 8800 once, working from a Byte book "Threaded Interpretive Languages", and used it to program a TMS9918 graphics chip (what TI99/4s used for graphics) wire wrapped on an S100 board and eventually worked up a little 'dungeon explorer' game with it, where a sprite moves around a 3x3 screen 'dungeon' w/ 3 levels (27 screens total). The video out went into an old color tv (direct! no rf modulator). Anyway, even on a 2Mhz 8080 FORTH was fast enough to flip screens into the 9918 with little noticible delay. One other project was rewriting the BASIC game 'Othello' in FORTH so it would play faster ;))
But that was 1983 and it was time to shelve the Altair and get an Atari.
try { do() || do_not(); } catch (JediException err) { yoda(err); }
The first is that you can define compile-time behavior (in the forth sense of compiling)--very cool. For example, you can create your own application-specific branching structures. You're not "limited" to if/then/else for example. Just roll your own quaternary branching statement if that's what you need!
The other is being able to (forced to?) build your own data types from scratch. I actually learned FORTH before I learned C. I was all bent out of shape when I found out that C automatically handled pointer and array offsets for me (e.g. *(x+3) actually means x+3*4 where 4 is the number of bytes for each x). I recall that at the time I felt C took me so far away from the machine whereas I was much closer to it in FORTH.
I remember a story I read in the famous German "c't" magazine many years ago:
;-)
Sometime in the 80s (Germany was still a divided country then), a competition was held for university students from all over Germany. The goal was to write a program to control a robot to perform some predefined tasks, with the team who took the shortest time to finish the program being the winner.
The teams from West Germany used their butt-kickin' (for the time) Intel-based systems (DOS, C, Pascal, harddisks and whatnot).
The competition, however, was won by the only team from East Germany. They used an U880 (a GDR Z80-clone running at 1 or 2 MHz) based Robotron computer which had maybe a tenth of the power of the other teams' computers, and Forth as a programming language.
Yep, it's not the size, it's how you use it
"There are already a million monkeys on a million typewriters, and Usenet is NOTHING like Shakespeare." - Blair Houghton
In many ways Charles Moore is a seriously twisted genius. I have always rooted for him, despite the fact I prefer to use a cleaner, more readable language.
Amen to that. A lot of Chuck's work, especially his new ColorForth, borders on the bizarre, but it's never drooling-in-the-corner bizarre -- it's always mad genius bizarre.
That being said, Forth is a lot of fun to work with even if you never do anything remotely useful with it. The underlying dynamics of a Forth environment are simple enough that you can roll your own very quickly, which is not something you're going to do with C or C++ or Java. Ultimately, that's what probably kept Forth from becoming more popular: the temptation to create new Forth-like languages was easily satisfied by Forth programmers. Case in point, of course, is Chuck Moore himself, who apparently despises the standard version of Forth and who has never stuck with one version of the language for very long.
Using Forth and building your own Forth environment is still a fascinating way to gain insight into interpreters and virtual machines, and the kind of thinking required for using Forth well is quite an enjoyable exercise. If you do want to use Forth for "real" work, it is worth bearing in mind that some very complex systems have been built very, very quickly by seasoned Forth programmers -- including air traffic control systems -- and the mode of bottom-up programming used in Forth basically ensures continuous unit testing, so Forth programs tend to require less debugging late in the development process.
Proud member of the Weirdo-American community.
what so special about Forth that Python can't do?
"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."
That sounds similar to what Paul Graham says Lisp allows you to do. Is it, or do I not understand what you're describing?. (I've never looked at Forth, so the latter is likely.)
1. Lower-level than C, yet slower in most real-world tests.
2. Significantly harder to maintain large codebases than Java, or C++.
3. Not as potent as Lisp.
4. Small compilation, interpretation, and execution.
Why do Sun, FedEx, and NRAO use Forth? My money is on: because they haven't switched to another language yet.
So, uh, does anyone have a Fourth "Hello World" program yet?
Preferably one that has email built into it.
I really hate Dan Patrick.
Hi guys (and gals),
.. etc., code that is
Reading this collection of comments about Forth certainly brings back
warm and nostalgic memories. My name is Henry Laxen, and back in
1983, my friend Mike Perry and I implemented the Forth-83 standard on
a bunch of different machines, including the 6800, 8086, 8080 and I
don't remember what else.
While it is easy to be derisive about Forth, believe me when I say
that there is a lot you can learn about programming, language
implementationand and especially "factoring" if you take the time to
study the language.
One thing Forth teaches you discipline. Back then, all we had was a
64K (not 64M) address space, and yet we managed to develop some pretty
impressive applications. I worked on the Panasonic HHC (the world first
hand held computer) which used Forth as its operating system and
application language. Inside of a 16K rom we managed to fit not only
the Forth language and operating system, but a memory based file
system, a calculator, a "memo pad" which allowed you to store
messages, an alarm clock/schedular, and the ability to add "capsules"
to extend the system. All this ran on a 6502 processsor.
Another great thing about Forth is that a single mind can read and
understand the entire Forth system, from low level inner loop to the
"meta-compiler" that allows Forth to compile Forth. Unlike C, PERL,
(which is my current favorite language), LISP, or God forbid C++, I
don't think there is any single human who can comprehend at the bit
and byte level how the whole thing works. With Forth you get the
whole language and operating system in less than, say 50 pages of
source code. Even a feeble mind such as mine can grasp the whole
thing. Those of you out there who are planning on making software
your vocation will learn many valuable lessons by putting some effort
into understand how and why Forth works, even if you never use it in
an application.
Another area where Forth "shines" is in debugging hardware. It
compiled/interpreted nature make it both very fast and very easy to
write simple little hardware probes, that even a hardware engineer can
be cajoled into understanding. I remember our hardware guys
marvelling at the "bright traces" they could get on the scopes after
writing one line of Forth code to probe a particular memory address or
io port.
Let me relate to you a few of the "sayings" we used to use back when I
was involved in the Forth world.
1. Inside every large program there is a small program crying to get
out.
2. In any piece of code larger than 1K, it is always possible to save
1 byte.
3. Never waste a cycle!
This was the nature of Forth, doing more with less. In these days of
gigabyte RAM and multi-gigabyte disk, it seems kinda silly, but the
nevertheless, the close interaction with the machine, and the
understanding gained as to what is really going on when you write a
program made learning Forth invaluable.
One last comment. Many people complain that Forth is a write-only
language, and that once the code is written no one else can understand
it. While this can be true if the programmer is lousy, just the
opposite can be true if the programmer is good. I invite any who
are interested to inspect the source code for the Forth-83
implementations that Mike and I put together, and I'm sure you will
find that with the proper factoring, and the proper choice of names,
your can be more readable than lot's of C, LISP,
out there.
Well, thanks for indulging me in this trip through languages of days
past. I will always be grateful for the lessons I've learned by using
Forth, even though I find that for web work, PERL is an easier choice
these day.
Best wishes,
Henry Laxen
I've seen some amazing things in forth. Entire production lines running on 8085 chips. Space invaders written in half an A4 page.
Nothing will every be able to do that again.
I'm about to make a major move and the Forth books ("Starting Forth","Thinking in Forth", "Threaded Languages" and 2 or 3 Forth Inc manuals were slated for the trash (ie a library book sale that will prolly do the honors). If someone throws shipping money (or wants to pick up in Tampa) in my direction, they are welcome to them. Let me know by 10AM 10/1 cuz they are goin',goin'......I think my email addr is in my bio somewhere.
ah, MOPS was beautiful. a few bugs here and there, but any language that is free and comes with all of its source - so that you spend hours trying to work out just how it does something - is a joy.
JForth was a professional FORTH implementation for the Amiga. It was very fast, and offered advanced features such as structures and GUI support. This FORTH was not traditionally threaded -- the "J" stood for "jump", and used 680x0 jump linkage between words. This gave it a lot of speed, at a tradeoff of making programs a bit larger than a "real" FORTH would.
:)
My first Open Source program was written with JForth. I called it IconJ. Its purpose was to allow the icon associated with a program to store various initialization values, and even scripts. In modern terms, it added a bit of object orientation to the file system. (I didn't think about it that way while writing IconJ, though.
- - -
"The sixth sick shiek's sixth sheep's sick."
Euskera, the native language of the Basque people, has a basic structure that is reminiscent of Forth. Whereas English speakers are used to a caseless prepostional system, Euskera speakers are used to a case-based postpositional system that leans mostly toward a "reverse" sequence of sintagms. Here are some examples in my (now rusty) dialect:[1]
Well, I could go on, but I think you get the point.
You can think of a case postposition (of which there are quite a few and which confer great functional specificity) as a sort of type marker, which makes Euskera a sort of object-oriented, reverse-notation language.[2]
__
[1] Any euskera batua fascists reading this can send their corrections of my grammar and spelling to /dev/null.
[2] Well, reverse for English speakers in any case, ha ha.
If you still have either in this environment, you're wasting money.
If you have a janitor, you're too proud to spend 10 minutes emptying a couple of wastebaskets, taking the stairs down to the trash bin, and running the vacuum over the floors every 2 days.
If you have to hire a web designer, you probably don't have the mentality to run a decent web based business anyways.
Aren't these sort of businesses already gone?
OLGA is still around. Of course, all the tab files are far from US soil (IIRC, the mirrors are in Poland, The Netherlands, and one other)
zForth is an open source Forth interpreter written by Bill Zimmerly. He hosts the Forth web ring at zforth.com. This site uses the zHTTP server, a web server written entirely in zForth.
i st&pag e=0
This is a list of Forth related stuff in the webring:
http://www.webring.org/hub?ring=forth&l
Back in the early 80s, there wasn't much to code on at home for us old geeks. I had an Atari 400, and it was either cartridge BASIC, or FORTH. It was a godsend; primitives (atoms) were written in 6502, you could write your own words in assembler, you could build a foundation, and get as high-level as you wanted, all in one compact, concise, efficient language. God, I miss those days. Of course, I don't miss having to upgrade my 48K of memory to 64K, but it was still fun.
"I think my email addr is in my bio somewhere"
I didn't see any. How much for third class shipping?
Paradoxically enough, that is true. While Forth is a completely unsafe, ridiculously simple to implement, machine near-language, Common Lisp is a big and complex language, trying to abstract away from the underlying machine as much as possible. Yet, they share this unique strength together, although in very different ways.
It was fun. But RPN is not a way to run a whelk stall.
There is a GPL'd Forth interpreter out there: GForth
It is the Forth implementation of the GNU project and is available for many platforms including Linux, Windows and OS/2.
There are 2 kinds of people in this world: Those who write in decimal and those who don't
I used Forth in the early 80s to build computer-based test equipment. It was super awesome for that purpose. (The stubborn avoidance of floating-point numbers was an irritant, but kept one on one's toes).
It always seemed to me that Forth and C were two solutions to the same problem: the need for a lightweight and portable computer language. Something very close to macro assembler, but with cross-CPU portability. Back in the "good old days", we didn't have CPU cycles or memory to spare -- to paraphrase Dr. Dobb's motto back then, we needed to run light without overbyte.
Forth seemed to attract the hardware types, like me. C attracted the software types. The world became overrun and dominated by software types, so we know who won.
As fondly as I remember Forth, I can't imagine that Forth would have much use these days -- modern languages are just so much more powerful.
Perhaps Forth would be useful for really terrifyingly critical embedded systems, say, for weapons or medical use. It seems to me that since Forth is so close to the hardware level, it lacks the inherent untestability and instabilities that occur in modern languages with their many levels of abstraction.
FBMuck is available at http://www.belfry.com/fuzzball/. I've messed around with it a bit: workable, but most of the code is still in C. What I'd really be interested in would be a MUCK written entirely in Forth (except, perhaps, for the socket code).
TANSTAAFI: There Ain't No Such Thing As A Free iPod.
I had a program in Fourth that would calculate pi to any decimal place you wished.
Converted to basic for the PET. I think i still have the printout somewhere......
Forth and Postscript share that both use RPN (reverse polish notation), and as a consequence have some similarities for stack manipulation. So do HP calculators and the Java virtual machine. Beyond that, however, the languages couldn't be more different. Forth is a low-level language with no runtime safety and no dynamic typing. Postscript is a dynamically typed language with garbage collection. Except for the use of RPN notation, Postscript is really closer to languages like Lisp.
But that is probably its main virtue. Once you move development "off board" and use a batch compiler, you might as well use a compiler (C, Modula-2, etc.).
Hi,
I have a cheap (but card-cover bound) copy of starting forth, which I wanna sell.
If you wanna buy it, I am selling it for $36 dollars, and free shipping is included for within
the USA (USPS.)
However, I will be willing to exchange it with any *old* book on Lisp (mail me first, to see if I have it.)
mail me at "jazzy_merchant yahoo at dot com"
After comprehending the force that sequencial pharsers together keeps, in reverse polish notation think you will!
-- Yoda in a cs class for young jedis
I wrote a decompiler that produced compilable Forth code from competitor's ROMs (and we had loads of laughs looking at their inept examples of programming, such as "1 = if 1 else 0 endif" which basically did nothing at all), and I also managed to squeeze in a 4K bytes ROM an insurance rate table with 10,000 integer entries (the second derivative did fit in three bits or something silly like that).
Forth is used as the backend scripting language for the 3D animation software Realsoft 3D. Realsoft also also happens to be my favorite dark horse candidate in the highly competitive 3D animation marketplace, notable because it runs on Linux.
When you think about it, a low level language like Forth is ideal for such an application. Realsoft strives for realtime OpenGL animation playback, with physically correct simulation, particles, deformation hierarchies and tons of geometry thrown at the screen. Forth is fast enough to solve custom animation expressions without getting in the way.
I'm sorry but I have a lot of trouble with FedEx being cited as the second "credible" company on this list. I know for a fact that FedEx's call centers are running programs written in FoxPro on DOS. Does that make FoxPro a great language? Even the author of the program (who wrote it in college in his free time while working there) would wouldn't agree to that, despite the fact that they're still paying him to support an app that they refuse to pay the money necessary to replace.
I also know that FedEx still has huge monolithic apps written in COBOL on IBM mainframes, since I get nice descriptions of them from my professor on Monday and Wednesday nights (he works there during the day). COBOL, people, COBOL.
I'll make a blanket statement as a Memphian who knows entirely too many people who are either employed by the company or serve as vendors to it: FedEx is a big slow giant that made a lot of decisions in a hurry that it doesn't want to pay to take back. For example, they just built a nice new world headquarters that consists of some of the most modern buildings in this part of the country (ok, not saying a _whole_ lot, but still) and what do they furnish them with? Yup, the furniture they bought in the '70s and '80s.
So when someone says "FedEx uses ____" I tend to ignore that fact and move on. Not every decision they've made is bad, but very few have anything to do with the technical merits of the choices given.
Or are talking based on your obvious prejudices?
COBOL is an excellent languages for many busineess oriented tasks and the cost of a replacement with something else (why, because it is "modern") may very well outweight any benefits.
IANAL but write like a drunk one.
Leo Brodie mentions that Thinking Forth is back in print, and he may be revising Starting Forth.
Using HTML in email is like putting sound effects on your phone calls. Just say <strong>no</strong>.
I asked BillZ for the URL, here it is:
http://www.zimmerly.com/wbz/zforth.tar.gz
Just MOV it! There you have total control over your system... with thousands of MIPS and gigabytes of memory (or whatever you call a decent PC today).
For those of you here who own a Mac and want to experiment with a little bit of Forth, there's a built in Forth interpreter in the Mac Chipset (also on some SUN machines). OpenFirmware, the Mac Firmware engine, uses forth and you can do some command line dicking with the stacks etc by pressing Command-Option-O-F at boot, which will take you into the Forth commandline environment.
Have fun and be careful because you can seriously damage your Mac with some careless forth scripts.