Path: utzoo!attcan!utgpu!jarvis.csri.toronto.edu!mailrus!shadooby!samsung!usc!ucsd!sdcc6!ir230
From: ir230@sdcc6.ucsd.edu (john wavrik)
Newsgroups: comp.lang.forth
Subject: Mini History
Keywords: FIG
Message-ID: <5565@sdcc6.ucsd.edu>
Date: 4 Dec 89 15:37:04 GMT
Organization: University of California, San Diego
Lines: 136


John Wavrik wrote:

# There is an historical precedent for what I am suggesting. About 10 years 
# ago, a group of independently minded programmers decided to make a new 
# language available to the general public. They implemented their model on 
# about a dozen of the most popular processors of the time. Most people who 
# got past the unconventional nature of the language found it almost 
# supernaturally powerful. 

Leo Brotzman replied:

#    I presume that you are referring to FIG Forth here.  The FIG model was 
# precedant setting, but is no longer in widespread use.  It has been quite a 
# while since I used FIG Forth, but I believe that even it had certain 
# implementation differences between processors. 

                                    -------

Let me address the historical aspects of Leo's message. Without doing some 
research, I can only make this a brief and somewhat personal account. I feel 
that the statement that "the FIG model is no longer in widespread use" is 
misleading. And this point has a great deal of relevance to the theme of the 
discussion. 

After a few years of using Forth for my research work, I decided to teach it. 
At the time (the early 1980s) this meant using a central computing system. I 
discovered that the Center for Astrophysics and Space Studies (CASS) at my 
school (UCSD) had a version of Forth for the VAX -- and they were happy to 
supply me with a copy. 

The CASS version apparently started with a DECUS version for the PDP-11. They 
took the original Forth block file idea literally -- my account had two 500 
screen block files (which, at the time, were more screens than I thought I'd 
use in a lifetime). The CASS version was like an archeological dig. No one 
ever erased a screen -- new definitions replaced old. One could see the 
evolution of word names and meanings. There was even a control program for a 
small telescope among the screens -- which gave an indication of how Forth was 
used. My only text was the "Kitt Peak Primer", written in 1979 and already out 
of date in 1981. The real flux in Forth seems to have occured between 1969 
(which FIG sets as the year of its discovery) and 1979 -- looking at Forth 
during this period is exciting: it is a period in which giants wrestled with a 
new concept. 

The Forth Interest Group did a very interesting thing at about this time. They 
defined a language by a model rather than a standard. Their model included a 
suggested implementation. As a result, they defined, in fact, a tightly mixed 
blend of language, operating system, language implementation, and mapping to a 
host processor. Forth is actually the name for Siamese quadruplets! 

I told my computer center that I wanted to teach Forth -- and they objected to 
the idea of each student using 1 Meg of disk space. I asked them to find 
something else and in short order they came up with two alternatives for the 
VAX. Each of these had coped with "the user owns the disk" problem in 
different ways. One was the version of Forth used by the Jet Propulsion 
Laboratory in Pasadena California, the other was the version of Forth used by 
the Kitt Peak National Observatory in Tucson Arizona. 

JPL-Forth used subroutine threading and text files. It was SLOWER than the
indirect threaded Kitt Peak, less sophisticated, and less well documented.
(In fairness to JPL -- this was an "in house" version which was not intended 
for export.)

Kitt Peak VAX-Forth was a "professional" version of Forth. It had to be 
installed by the computer center -- but it was equivalent in all respects
(performance, documentation, etc.) to any of the other languages we had 
available. Kitt Peak VAX-Forth was a FIG-Forth accompanied by extensions
which its developers found appropriate (it used block files in exactly the
same way as F83 and other modern Forths, it had floating point, it had hooks 
to the underlying VMS and Unix operating systems -- and it also established 
mechanisms for 16/32-bit compatibility, conditional compilation, multiple data 
types sharing the same stack, etc.)

We picked the Kitt Peak -- not only was it more efficient and better 
documented, but because many useful utilities (like a decompiler found in
the 1981 Forth Dimensions) could be easily made to run on it. People tend to 
forget that the incredible portability of the FIG model was responsible for 
interest in the Forth language during the early 1980s.

By the time I wanted to teach, the Forth-79 Standards had appeared. At home I 
was using a commercial Forth-79 produced by a software house that made its 
money writing Forth applications but also sold the version of Forth it used. 
As it turns out, Forth-79 differed from FIG-Forth in only a few words: 

        WORD       --   in FIG it did not leave an address (but the address
                        was the end of the dictionary)
        <BUILDS    --   replaced by CREATE
        VARIABLE   --   required an initial value in FIG-Forth
        NUMBER     --   I no longer remember the precise difference

At any rate, I made VAX-Forth look like a Forth-79 with a few screens of
adaptation  (several years later Martin Tracy was to call this a "prelude").

WHILE BROTZMAN MAY TECHNICALLY CLAIM THAT FIG-FORTH DISAPPEARED AT THIS POINT,
IT WOULD BE MORE ACCURATE TO SAY THAT IT BECAME THE FORTH-79 STANDARD. 

The 1983 Standards were different in character than those of 1979. There were 
no major changes in the way Forth is implemented (although the 1983 Team 
seemed to be the first to try to separate the quadruplets) but the '83 team 
had several "better ideas" which produced "gottchas" [for non-English 
speakers: a contraction of "I've got you" -- that is, "you've fallen into my 
trap" -- it's something said by razors when you try to shave quickly].

The 1983 Standards Team tried to improve the language by "fixing" things they 
felt were wrong. As a result, they changed the actions of important words -- 
some in subtle ways. The change in ' (tic) was up front and visible but I can 
vouch for hours spent trying to track down why some '79 code did not run on 
'83 (EXPECT-83 does not put a 0 at the end of input the way EXPECT-79 did). 

The irritation caused by some of the minor nuisance changes, and the 
resulting backlash should not mask two important points:  (1) The 1983 Team 
did not substantially change the language; (2) Many of their points were well 
taken (but not balanced against the effect on portability of earlier code). 

The fact of the matter is that a good many versions of Forth, including Laxen 
and Perry's F83 (which may be one of the best Forths ever written) are direct 
descendants of FIG-Forth.

While the issue of implementation and standards does need to be discussed,
I think it is important to understand that FIG-Forth was not something tried 
and abandoned  -- quite the reverse!

We are dealing with a language that has a 20 year history. Some of the papers 
presented at the recent Forml conference were rediscoveries of ideas which can 
be found in the papers and systems of the early 1980's. It is the conceit 
of the young to believe that until they were born no one was smart enough to 
discover what they have discovered. Fortunately God invented old people to 
tell them otherwise. If it were not this way, we would have no progress.

                                                  John J Wavrik 
             jjwavrik@ucsd.edu                    Dept of Math  C-012 
                                                  Univ of Calif - San Diego 
                                                  La Jolla, CA  92093