[TenTec] Yep -- Omni VII

[Grant Youngman]

> I had to write SNOBOL code in my Artificial Intelligence 
> class back in college in the 1970s.  I haven't had to touch 
> it since.  I'm pretty sure that's a good thing.  I had to 
> learn LISP for that class as well.
> LISP was more interesting.

SNOBOL (SNOBOL4, SPITBOL) and other variants were interesting ideas.  SNOBOL
was never a commercial success, but was used a good bit in
university/library research, and found some applications in, shall we say,
classifed spooky kinds of endeavors.  As did LISP, which is just a WONDERFUL
language to work in -- but definitely requires something other than a
programming-trade-school-read-the-latest-book way of thinking, unless
somebody out there begins teaching recursion in the equivalent manner of a
piano student learning scales, on the first class day.  What the heck is a
CDDADAAR anyway .... It's actually a (CDR(CDR(CAR(CDR(CAR(CAR())))))) .. But
what does THAT mean, and how do you parse it??? :-)

The string processing concepts created in SNOBOL, and in COMIT and COMIT-II,
are present in most modern languages -- so they havn't really disappeared,
they've just shown up in disguise.  There's a point there which I'll get to
in a minute.

I wrote several LISP compilers in the 60/70's on diferent machines, and have
an absolutely overwhelming fondness for the language.  One of those was a
multi-phased bootstrapped thing that ultimately was self-compiling.  LISP
seems to be making something of a comeback and I think it's the perfect
vehicle for many applications.  It began to fade before memory got to be
cheap, because it can be a hog, but memory's now almost free.  I did one
implementation that extended the stack (which can grow very VERY large in a
massively recursive application) to mag tape -- it worked but was equivalent
to beating an entire herd of dead horses :-) 

And then there's JOVIAL, but that's another issue altogether :-)  There's a
lot of JOVIAL code in the B-2 and F-117 imbedded systems and other mil
systems, although it isn't something that one encounters in the usual
undegraduate curriculum.

There are many "family trees" of programming languages out on the web, I
suspect put together as projects by eager under/grad students born too late
(or just typically non-rigorous and doped up) to have a good grasp of the
early years of the subject.  Most are boring (FORTRAN, LISP, BASIC, PASCAL,
C, PERL, ***SNORE***) and leave out a lot of the really interesting and
innovative stuff, especially the languages developed for one-of-a-kind
research machines and the like, and are grossly oversimplified. Many of
those "missing" languages and underlying machine constructs contributed
"that one thing" we use without even thinking about it today.  A few of the
family trees are reasonably complete.  There's a lot of interesting history
in general in languages and operating systems over the last 50+ years behind
where we are today.  Where, for example, would MS or any system be today
without ALGOL's notion of the "thunk" .... They're everywhere, even though
the name has generally disappeared.

And speaking of the machines -- those things that have to DO what the
compilers tell them to do -- the 68xxx is/was a wonderful elegant
symmetrical architecture.  It's too bad we ended up with the Intel mess.
Those that love the Intel programming model just don't appreciate how good
things might be if the tsunami had blown in the other direction ....

End of rant ... 

To keep this on subject, the Omni-VII sounds like a radio worth looking at,
but I still like both Orion generations and am willing to forgive the faults
-- for now :-)

Grant/NQ5T