On 28 Aug 2001 07:57:31 +0900, Sean Middleditch wrote:
> Oh.  ::sigh:: another language added to the growing stack of languages I
> need/want to learn now.  Was Algol that highly used of a language?  I've
> not heard much about it.

It's more valuable to learn families of languages than specific
languages. If you choose to learn something Algol family of languages,
you'll have a fair idea of what Algol's about. Studying specific
languages within the family is more useful for seeing implementation
tradeoffs and the effects of emphasising one facet over another.

The most valuable language I ever learned, even though I can hardly
write a loop in it these days, was Forth. It's truly amazing to see so
much done with so little - highlighting the power of introspection and
direct access to language internals. The power of "DOES>" is truly
phenomonal - allowing the programmer to switch between compilation and
interpretation in mid-stream.

This is how the Forth word   ."   (to print a string) was implemented -
the interpreter sees   ."   , then starts feeding raw program code
directly to the program itself. The    ."   word happens, in this
instance, to just output everything it gets until another " is reached.
There's nothing to stop this string from being parsed any other way, so
each command could have custom syntaxes as parameters. The language
could be, and was, written in itself, outputting direct to bytecode
while the programmer typed - there was no interpretation or compilation
pass. There has never been a simpler and more elegant implemetation of
eval than this!

This flexibility came at a price - the more this facility was used, the
harder it is for someone else to pick up the code and understand what's
happening. This, I think, was the nail in Forth's coffin (along with its
RPN)- but what a coffin! It occurs to me that writing for a Forth stack
machine, with an embedded Forth language to create more machine on
demand, could be more interesting than the current bytecode machine.
There's no speed issue either, as Forth machines are blindingly fast.

Back to the topic... My list of languages to know:

  An early assembler designed for human programmers (eg, one of: Z80,
6502, 68030, VL80C010) to understand CPUs
  C for compatibility with other programmers, and to see how higher
level abstractions can layer over the top of assembler
  Forth to see how a more complex machine model (stacks instead of
registers) leads to far greater flexibility.
  Ruby for a human oriented language that a computer can handle.

Then a few other ones to a lesser degree, eg, "sh" for its concept of
piping and building quite interesting little scripts by joining programs
together, Prolog to find out how many times you can throw up in a row
without fainting, BASIC for the crack cocaine of languages, Logo to see
the program itself in a graphical manner, and so on.

What's nice about Ruby is that it takes more of the best while remaining
conceptually small. It doesn't have all of them, but perhaps the use of
one great feature would make it more difficult to use the other great
features...

Now I think I'll go off and play with writing Forth in Ruby. :)