When I meet people who tell me they want to learn all
about computing, including programming, I want to say learn
Forth. But I know that woun't work since they can't even go
to the bookstore and buy a book about it. Well at least they
can still get some nice books about Logo to get then started.

--
((( DANGER )) LISP BIGOT (( DANGER )) LISP BIGOT (( DANGER )))

Fernando D. Mato Mira
Real-Time SW Eng & Networking
Advanced Systems Engineering Division
CSEM
Jaquet-Droz 1                   email: matomira AT acm DOT org
CH-2007 Neuchatel                 tel:       +41 (32) 720-5157
Switzerland                       FAX:       +41 (32) 720-5720

I remember a Forth-like program I ran on the KIM, sitting at the
teletype in my kid's room working out algorithms to move an NC machine
in arbitrary circular arcs. I remember being annoyed because it seemed
that the major difference from Forth was the renaming of words just to
be different. My recollection that it was called Focal is evidently
faulty. Does anyone know what it might have been? (I had a video RAM on
that KIM, connected to a small TV monitor so I could plot the
trajectories. It was a better machine for my purpose than the mainframe
at work.)

        M[UMPS] by example: operators
        http://www.jacquardsystems.com/Examples/operator.htm

I quote:

        M[UMPS] evaluates strictly from left to right, so that 1+1*2
        yields 4 and not 3.

Michael

Thanks for the pinter!

+---------------
| M[UMPS] evaluates strictly from left to right, so that 1+1*2
| yields 4 and not 3.
+---------------

Well, what can I say?!?  FOCAL *was* inspired directly by MUMPS, yet
it *did* have operator precedence, for arithmetic exprs at least --
I remember coding that part of FOCAL-10 as direct transliteration
of the FOCAL/F code. There was a separate small data stack for
intermediate results. (And a FOCAL-in-C snarfed off the net some
time ago agrees, too.)

Oh, well...

-Rob

Thanks for the pointer!

+---------------
| M[UMPS] evaluates strictly from left to right, so that 1+1*2
| yields 4 and not 3.
+---------------

Well, what can I say?!?  FOCAL *was* inspired directly by MUMPS, yet
it *did* have operator precedence, for arithmetic exprs at least --
I remember coding that part of FOCAL-10 as direct transliteration
of the FOCAL/F code. There was a separate small data stack for
intermediate results. (And a FOCAL-in-C snarfed off the net some
time ago agrees, too.)

Oh, well...

-Rob

     The best book I've ever seen on programming for any
language was written for Forth -- "Starting Forth" by Leo
Brodie. Unfortunately this is out of print and available only
thru special order; its not on the shelf of bookstores like it
was for over ten years. There is one new book on Forth for
experienced programmers available from Amazon.com (not
bookstores) and also Forth Inc (http://www.forth.com). Of the
very roughly 100 versions of Forth available for various
computers and operating systems, 10 or 20 have some
documentation that will show how to use Forth for someone who
already knows how to program. The other systems assume that you
have read a book like "Starting Forth" or have learned another
version of Forth and can reverse engineer uncommented Forth
source code. There are several tutorials and articles on the web
that are very good and the amount of material is slowly growing.
See the FAQ for comp.lang.forth for a list. Actually there are
too many web pages for Forth and it is hard to sort thru all of
them to find the ones that tell you exactly what you want to
know. If you don't find what you need, post a message to
comp.lang.forth stating your favorite operating system, cpu and
applications and someone point you to the right place.

     I just looked for Forth books on amazon.com. Yes there
are several listings. There is only one listed as being in
print, and they say expect delivery within 4 to 6 weeks. There
are also listings for books by Leo Brodie. When I clicked on
"Thinking Forth" I got nothing but a system error. There are
five separate listings for Leo Brodie's book -- "Starting
Forth". That's reasonable since it is at least five times better
than the average book on programming. But its out of print. Its
available only by a special search. It will take them weeks to
find it or tell you if its not available. They don't tell you to
get it faster from the Forth Interest Group in California,
http://www.fig.org/ (at least until their special printing runs
out). Relying on amazon.com to sell Forth textbooks is not a
good thing. It would be better to have a publisher promoting the
book and getting it into bookstores.

     Elizabeth Rather is much too shy and modest. She failed to
mention her own book the "Forth Programmers' Handbook". So I'll
tell everyone that it is the one Forth textbook that is in print
and for sale at amazon.com. When I go to my local technical
bookstores to see if it has finally arrived on the shelves (it
hasn't), I find instead books on the equally neglected computer
languages Lisp, Scheme and Logo. I think that Lisp and its
relatives are much more lively than Forth since they still have
recently revised textbooks for sale. Since Forth is still being
used, I can deduce that Lisp is still being used, even tho I
don't know where. But how long will Forth last without at least
a few easily found textbooks?
I wish old Forth programmers would become inspired by Lisp
programmers to write textbooks so they would be able to train
their replacements.  

  ...

Mark

  something important happens when a previously privileged position in
  society suddenly sees incredibly demand that needs to be filled, using
  enormous quantities of manpower.  that happened to programming computers
  about a decade ago, or maybe two.  first, the people will no longer be
  super dedicated people, and they won't be as skilled or even as smart --
  what was once dedication is replaced by greed and sometimes sheer need as
  the motivation to enter the field.  second, an unskilled labor force will
  want job security more than intellectual challenges (to some the very
  antithesis of job security).  third, managing an unskilled labor force
  means easy access to people who are skilled in whatever is needed right
  now, not an investment in people -- which leads to the conclusion that a
  programmer is only as valuable as his ability to get another job fast.
  fourth, when mass markets develop, pluralism suffers the most -- there is
  no longer a concept of healthy participants: people become concerned with
  the individual "winner", and instead of people being good at whatever
  they are doing and proud of that, they will want to flock around the
  winner to share some of the glory.

  Lisp is not the kind of language that insecure losers would use.  people
  do not want to learn Lisp because they stand a better chance of beating
  another unskilled fool in the job race.  fact is: you don't get a job by
  lying about your Lisp skills.  all of this means that there is very
  little activity at the front gate, where all the journalists and the
  media are.  there are no people struggling like mad to get into the Lisp
  world.  they don't have to.  if you want to learn Lisp, you go learn Lisp
  and talk to nice people who probably have time for you, and you make
  yourself good at it.  then you go do complex stuff that insecure losers
  who lie about their Java skills can't even imagine, and therefore do not
  consider part of the competition.

  neurosurgery is another field that requires an actual investment and lots
  of dedication to get into, is really rewarding to those who get good at
  it, but whose jobs are not advertised in regular newspapers.  there is a
  shortage of neurosurgeons, but very little advertising in the media that
  the patients read.  programming is both similar and different.  whether
  you are a user or a programmer these days is often hard to tell (this has
  good qualities to it, too), but some programming tasks are still reserved
  to highly skilled people who are not afraid to take huge risks.  ignoring
  for a moment the power of the American Medical Association, we still
  wouldn't see a huge amount of books on neurosurgery for dummies in 21
  days or whatever.  it's just plain inappropriate, and it's intentionally
  out of people's reach.  Lisp is somewhat like that.  people can get lots
  of medicines at the drugstore, but they can't be trusted to carve out a
  malignant tumor in their child's brain.  all sorts of users can do lots
  of customization and cool stuff in their "apps", but they really can't be
  trusted to run actual flight control systems, configure the telephone
  network, write software for video-synchronized magnetic-resonance imaging
  for brain surgery, or write automated stock-trading systems.  at some
  point, the risk of letting unskilled people do the task becomes too
  high.  that's when you can't trust more than 1% of the programmers out
  there, and a surprisingly large number of them know and use Lisp and
  tools that are can be trusted.  (consider an ATM that gets one of those
  frequent Windows crashes, or a naval warfare vessel that has to cold-boot
  because a certain display suddenly goes all blue, or any other story in
  comp.risks that would have been hilarious if it had been a joke.)

  another way to look at this is to see that software in today's society
  has a number of diseased elements, to consider that maggots eat only
  diseased or dead tissue, that dead or dying software projects lie around
  all over the place, like a horrible war zone between ignorant users and
  frightened managers, and pretend that you're a maggot.  you wouldn't care
  about the living and the healthy who prosper outside the war zone, you'd
  rush to the war zone to join the feeding frenzy, right?  so, to complete
  the grim picture, software in our society is diseased, the activity you
  read about are all about cleaning up the disasters and surviving the
  equivalent of plagues, and it just takes a tremendous amount of people
  and work to keep the whole system from dying, like the incredibly stupid
  year-2000 problem.

  to take but one simple example: suppose you thought of the new millennium
  when you wrote your application back in 1972 -- not only wouldn't you be
  invited to the party, those who knew you had done it right from the start
  and who probably laughed at you at the time would positively hate you
  now, and they sure as hell wouldn't tell people about you.  and the more
  stupid they are, the more important it would be to pretend that nobody
  was smart enough to see the next millennium coming.

  Lisp is a little too much out of the reach of the masses, and this needs
  fixing, but the professional markets are not into language-of-the-week
  contests and feeping creaturism in whatever won last week.  when your
  application takes longer to create than three versions of the JDK, you
  don't use Java.  the same applies to other long-term stuff.  when you
  write manuals for naval or air force vessels, you don't use MS Word and
  hope Microsoft doesn't come out with yet another incompatible disservice
  pack and/or upgrade, you use CALS and enterprise-wide publishing systems.

  put yet another way, even though aviation has become a commodity and ever
  more people fly around the country for the fun of it (well, maybe not,
  but it's certainly not for the food), you don't see people complaining
  that business class is in the decline.  instead, you notice that there is
  fierce competition in the cheaper tickets, but routes are set up mainly
  to accomodate business travelers, and if you're willing to pay for it,
  all sorts of amenities are available and life in the air is a lot better.

  Lisp is not only object-oriented, it's the business class programming
  language.  (it really is the first-class programming language, but let's
  talk about that when you have enough mileage.)

  now, since you're worried about Lisp "dying", consider this: Lisp is used
  a lot of places where all else has failed.  some people are smart enough
  (or have been burned enough) to use Lisp from the start, but just as you
  can't expect people to pay for insurance until they have a reasonable
  idea about the risks that exist around them, most people have to get
  burned before they understand the value of investing in not failing.

LISP in Forth exists. Well, it doesn't try to emulate LISP but it adds
a LISP-like vocabulary to Forth, mainly list building words with garbage collection. The original
F-PC code for it is on Taygeta, it even has some documentation.

The GC stinks, I never got it to reliably work in a 32-bit flat model
Forth (iForth) after I converted it from its segment-based origin.

I've added some Prolog code to it published in JFAR (Feuerbacher?). The
demo is a rule-based AI program to determine animals :-)

Nonsense - that's been by far the minority of books I've ordered from
them - for instance, the first language book that I could think of,
"C: A Reference Manual", is claimed to ship in two to three days.

Certainly, number of in-print books and their expected delivery time
is not a bad way of getting a first estimate for the 'health' of a
language! Counting the number of currently-supported compilers you
could use to produce marketable software isn't a bad one either.

[ followups trimmed ]

IMHO Forth and Lisp are much closer to each other than to the rest of
the language space (Algol, Fortran, Cobol and derivatives).

--
Bernd Paysan
"If you want it done right, you have to do it yourself"
http://www.jwdt.com/~paysan/

I was just at two bookstores near TU Wien.  I did not see LISP,
Scheme, or Forth books.  Interestingly, I did not even see a Prolog
book, although we have an obligatory Prolog course in our curriculum;
apparently the course notes are good enough.  I saw books for some not
so popular languages: Ada, Haskell, Icon, Miranda, ML, Modula-2,
Oberon.

Concerning the metric you use to evaluate the health of a language: I
think we have now enough experience to conclude that it is wrong.  You
whined about the lack of Forth books five years ago, but I see no
indication that Forth is any worse off than then, on the contrary,
other indicators are usually positive: clf traffic has grown, there
are fewer "Forth is dying" postings, implementations for new platforms
(e.g., PalmPilot, Lego Mindstorms) are demanded and supplied quickly,
participation at EuroForth is stable...

Moreover, there are several on-line Forth courses, so why would they
need to buy a book in a bookstore to learn Forth?

Using my metric of postings in comp.lang groups, here are the postings
present on news.tuwien.ac.at on July 11, 1997 and July 16, 1999.  You
will notice that a lot of newsgroups have vanished, that's because
this newsserver has dropped groups that nobody here reads:

1997    1999
        3       comp.lang.JavaScript
476     268     comp.lang.ada
206             comp.lang.apl
6       2       comp.lang.asm
786     581     comp.lang.asm.x86
78              comp.lang.asm370
117     144     comp.lang.awk
1               comp.lang.basic
447             comp.lang.basic.misc
114     646     comp.lang.basic.visual
282             comp.lang.basic.visual.3rdparty
691     760     comp.lang.basic.visual.database
3115    3429    comp.lang.basic.visual.misc
39              comp.lang.beta
2458    2471    comp.lang.c
2286    2518    comp.lang.c++
59              comp.lang.c++.leda
328     568     comp.lang.c++.moderated
51      63      comp.lang.c.moderated
968             comp.lang.clarion
731     655     comp.lang.clipper
224     625     comp.lang.clipper.visual-objects
32              comp.lang.clos
23              comp.lang.clu
485             comp.lang.cobol
5               comp.lang.cplu
5               comp.lang.crass
40              comp.lang.dylan
334     152     comp.lang.eiffel
6               comp.lang.for
233     470     comp.lang.forth
53              comp.lang.forth.mac
421     473     comp.lang.fortran
57      87      comp.lang.functional
31              comp.lang.hermes
31      28      comp.lang.icon
32              comp.lang.idl
122     183     comp.lang.idl-pvwave
309     252     comp.lang.java
815     1318    comp.lang.java.advocacy
12              comp.lang.java.announce
137     72      comp.lang.java.api
118     178     comp.lang.java.beans
        210     comp.lang.java.corba
        2       comp.lang.java.database
277     394     comp.lang.java.databases
        4       comp.lang.java.developer
391     1045    comp.lang.java.gui
772     1625    comp.lang.java.help
15              comp.lang.java.javascript
84      171     comp.lang.java.machine
208             comp.lang.java.misc
3440    3864    comp.lang.java.programmer
194     212     comp.lang.java.security
40              comp.lang.java.setup
223     295     comp.lang.java.softwaretools
259             comp.lang.java.tech
1732    2869    comp.lang.javascript
16              comp.lang.limbo
197     791     comp.lang.lisp
24              comp.lang.lisp.franz
46              comp.lang.lisp.mcl
25              comp.lang.lisp.x
130             comp.lang.logo
136     110     comp.lang.misc
14              comp.lang.ml
88              comp.lang.modula2
69              comp.lang.modula3
171             comp.lang.mumps
72              comp.lang.oberon
66      101     comp.lang.objective-c
55      26      comp.lang.pascal
69              comp.lang.pascal.ansi-iso
664     297     comp.lang.pascal.borland
23      51      comp.lang.pascal.delphi
163             comp.lang.pascal.delphi.advocacy
21              comp.lang.pascal.delphi.announce
49      21      comp.lang.pascal.delphi.components
306     140     comp.lang.pascal.delphi.components.misc
222             comp.lang.pascal.delphi.components.usage
306     77      comp.lang.pascal.delphi.components.writing
1               comp.lang.pascal.delphi.database
888             comp.lang.pascal.delphi.databases
2061    864     comp.lang.pascal.delphi.misc
67              comp.lang.pascal.mac
221     111     comp.lang.pascal.misc
56      165     comp.lang.perl
7       1       comp.lang.perl.announce
1865    4223    comp.lang.perl.misc
        260     comp.lang.perl.moderated
256     411     comp.lang.perl.modules
115     232     comp.lang.perl.tk
41              comp.lang.pl1
28              comp.lang.pop
284     252     comp.lang.postscript
77              comp.lang.prograph
83      97      comp.lang.prolog
404     999     comp.lang.python
141     155     comp.lang.rexx
3               comp.lang.rexx.tso
4               comp.lang.rexx.vm
26      51      comp.lang.sather
160     178     comp.lang.scheme
32              comp.lang.scheme.c
26      12      comp.lang.scheme.scsh
491     430     comp.lang.smalltalk
737     1235    comp.lang.tcl
23      7       comp.lang.tcl.announce
95              comp.lang.verilog
155     190     comp.lang.vhdl
2               comp.lang.visual
44      380     comp.lang.visual.basic
260     209     comp.lang.vrml

According to these numbers, both clf and cll traffic has grown a lot
in these two years, so I doubt that these languages are dying.

For more statistics, take a look at
http://metalab.unc.edu/usenet-i/hier-s/comp.lang.html.  E.g., it
claims that clf has 24000 readers, and that cll has 31000 readers.

The true question is, is the growth rate of comp.lang.forth greater
than or less than the growth rate of Usenet traffic in general?  I
wouldn't say that more articles in, for example, talk.bizarre means
that the world is necessarily getting more bizarre.  I'd say rather
that more bizarre people are posting more.  What's the average
increase in posts in *lang* groups, and where does comp.lang.forth
stand on the curve?

Barry

  of course they are.  however, have you ever seen how much work it takes
  to boot a modern Unix machine and run a C program just to have it print
  "hello world" in an xterm running under MOTIF?  man, it sucks.  and it's
  even more work if it tries to run NT.  the machine should be doing a very
  limited amount of work for this very simple task, but instead it spends
  minutes booting and preparing itself to be useful, not to mention all the
  crap necessary to get a program in C able to produce that output.  yea,
  verily, it sucks.

  unfair comparison?  not at all.  why do you think they chose that phrase?
  because they were developing Unix and the C compiler.  it's appropriate
  to make a machine print "hello world" to verify that everything works
  after all the mind-boggling nonsense has interfered with the real purpose
  of a computer, and you never know which part of booting up will fail due
  to a minor bug.  the delight in a C programmer's eyes when his machine
  thus booted typed "hello world" back at him would probably parallel that
  of a Common Lisp programmer when the satellite communications subsystem
  he designed beams back "hello world" after an almost-aborted launch, a
  navigation jet which misfired, and the solar panels sustained some damage
  by space debris.  normally, it's unnecessary to have confirmations of
  basic operations, but it makes perfect sense under C.

  there are other simple tasks that require a tremendous infrastructure to
  make a trivial task come back with a positive result.  e.g., you need DNS
  to be set up right, routers and firewalls must to do their job, the local
  network and telecommunications links must let stuff through, etc, before
  you can type "ping elvis" and have the system type "elvis is alive" back
  at you.  this is actually so delighting that there is a disproportionate
  number of machines called "elvis" for this particular reason.  (I think
  it would be much more fun to have machines called "thelma" and "louise".)

  who, these days, would pick up a telephone and consider "hello" to be a
  landmark event in human history?  while there's nothing wrong with a
  strong sense of fascination with "all that which just _works_ around us",
  getting excited about "hello world" programs appears to me to be a sure
  sign of insanity, or at least a fairly constant case of missing the boat.

| it's just that unix and windows are set up to support C and C++.  e.g., C
| has a largish libc these days.

  these two statements are pretty much contradictory.  the problem is that
  neither Unix nor Windows _actually_ support either C or C++, but they
  manage to make them work, with downright incredible effort.  if you look
  inside the libraries and see how a system call actually works and how
  much it differs from the C calling convention and usage, you'd be a fool
  not to revise your opinion.  and _does_ an operating system that forces
  the programmer to check to see whether the operating system did what it
  was asked to do every damn time you ask it to do anything actually give
  any relevant form of support to anyone?

  in my view, Unix and Windows support Common Lisp better than they support
  C because C is designed for a 70's style machine and operating system,
  which modern machines and operating systems have to mimic with all their
  flaws and misdesigns, while Common Lisp is a modern language that is well
  suited to be hosted on modern systems, and it just happens to be, too.

  the irony here is that Common Lisp has been what these machines and
  operating systems have aspired to support for all these years and now
  that they have finally grown to the task, people have so many problems
  with the software written while they were growing up that day-to-day
  survival has obscured everything to the point where people who are too
  young to know that computers were designed to help people think better,
  not just do the same old menial labor faster, believe there is nothing
  more to it than luring lots and lots of people to perform menial tasks by
  mouse instead of by lever.

  anyone remember how the fear that machines would take over the world
  quieted down as Bill Gates started to peddle his limpware?  the computers
  sure did take over the world, but whoever is afraid of toothless little
  poodles who all wag their tails when they expected monsters?  imagine a
  little icon that said "My Scary Monster" or "My Scary Neighborhood" and
  a browser that said "abandon all hope ye who click here".  wouldn't sell
  much, would it?  and that's why they are called "confidence games".

  I remember someone saying that if it hadn't been for automatic switches
  in the telephone network, the entire population of planet earth would
  have had to be telephone operators to handle the load of telephone usage
  in 1993 or thereabout.  I get the eerie feeling that because modern
  computer systems are so incredibly braindamaged in their design and in
  the tools used to program them, the entire population of planet earth
  will be programming these idiotic boxes pretty soon if managers don't
  wise up to the fact that the equivalent of automatic switches already
  exist and have done so for at least 20 years.  yet if Y2K doesn't light
  up most manager's view of the world of programming, there isn't hope for
  mankind at all.

  so, yeah, Lisp is dying because we all have to program in C++ to Bill
  Gates' tune, so we don't have time to think about making a better world
  with better languages and less menial nonsense in programming computers.
  the same thing happened in the last revolution, but fears in those times
  caused labor unions and a strong sentiment against all business in some
  quarters.  user unions these days can't even stop the U.S. Congress from
  enacting more laws to protect the software companies from Y2K lawsuits.

  but of course, Lisp isn't dying -- it's just that if you think in terms
  of the imminent end of the world, _everything_ is soon food for the great
  garbage collector in the sky and whoever is not scrambling in panic looks
  like they aren't moving and have been passed by or are dying.

  the problem I see is not that Bill Gates has shaped the world of useless
  trinkets in software, but has also managed to spread his competitiveness
  and his personal fear of losing to imaginary competitors to businesses
  and homes everywhere, so now everybody is _afraid_ of losing some battle
  which isn't happening, instead of getting about their own lives.  like,
  if you aren't using today's fad language in the very latest version of
  the IDE, you'll be left behind.  aaaugh!  but it's good that some people
  run like they are scared out of their wits.  if they suddenly disappear
  over the edge of a cliff, a good number of people will notice in time and
  _not_ follow them.  those are the ones that matter.

  you can scare most people most of the time, but you can't scare all of
  the people all of the time -- some will always use Common Lisp.