Re: [Chicken-users] Re: YADT: yet another documentation thread

[Alaric Snell-Pym]

On 18 Feb 2008, at 6:45 pm, Peter Bex wrote:

> A little painful to admit, but I started out with BASIC on the C64,
> then got
> a PC with QBASIC/QuickBASIC, then my first "real" language: C.  I
> stuck with
> C for a long long time until I learned Scheme at university.  That
> was love
> at first sight and I've been using it ever since :)  PLT first,
> then a little
> bit of s48 and then Chicken.

I started with BASIC on a ZX Spectrum, thence to Turbo BASIC on a PC
(an original PC! Not the XT, which had a hard disk, but a real PC
which had to have a 20MB hard disk on a card fitted, and would still
only boot from floppy!), then Pascal (again Borland's Turbo version),
then to 8086 assembly and C, more or less in parallel.

However, I was always taking books out of the library on other
languages. The local library was stocked with computer books in the
1970s and early 1980s when new programming languages weren't so
stigmatised as they are these days, so I read books on Lisp, FORTH,
FORTRAN, COBOL, Prolog and ADA as well as the ones I actually used;
but I didn't have any access to implementations.

But for my 14th birthday I was gifted with a then-new Demon Internet
account, and online, I found myself able to download implementations
of more languages, and access to Usenet: comp.lang.* in particular
caught my interest. I was confused about this concept of 'functional
programming' for a while, since all the descriptions of it I saw made
no sense. "Imagine programming without assignment" - uh, how would
*that* work?

So, for my 16th birthday, I asked my father for a stack of books I'd
heard recommendations of but hadn't been able to find. One of which
was SICP, which was my first introduction to Scheme. I also picked up
a book (well, *the* book, as far as I can tell) on Dylan, since that
seemed cool.

Anyway, I remember my surprise when, reading SICP, it said "Now we'll
cover assignment. What we've been doing so far is called 'functional'
programming", or words to that effect, since the way it was done so
far had all seemed perfectly sensible to me - I'd not actually
noticed the lack of assignment at all...

So yes, I liked the look of Scheme; it had a property I had begun to
notice in a few languages, that it simple to implement simply, yet
didn't preclude more efficient implementation in the way that, for
example, TCL with its everything-as-a-string would. This it had in
common with FORTH, and FORTH also had the fascinating metaprogramming
facility, not unlike defmacro (although I'd not come across macros in
the Lisp world at the time, with SICP rather skipping them).

However, I didn't have much chance to play with it in depth for a
while, since most of the programming I was doing required specific
libraries or whatever. Then I went off to University, where I had to
pick up a bunch of languages required for exercises: Java, Object-
Oriented Turing (a rather toy Modula-esque language), Haskell, a few
different assembly languages (as well as using C and Prolog, which I
knew anyway, but actually being forced to do exercises in Prolog
rather than just reading and thinking about it was a bit of an eye-
opener).

When it came to final year project time, however, I managed to talk
the lecturers into letting me do my own project rather than picking
one from their menu. And my project was in macro systems, as I had a
cunning plan to try and merge FORTH's metaprogramming system with
Scheme, which in effect involved a very low level macro system (I was
rather taken with minimalism in programming languages, you see).

Meanwhile, I was also working part time, so having to do more serious
Java, as well as PHP and a bit of Perl. I picked up Python myself out
of interest, since it looked like a better Perl.

Only recently did I have to learn Ruby. Ruby's... not *that* bad,
it's sort of half way between Python and Perl IMHO. So a bit cleaner
than Perl, but still with crufty misfeatures such as "do what I mean"
overloading, special core global variables like $_ and $` and all
that, regexps in the core language (there's more to life than
analysing strings, you know...), and so on. But Rails, however,
builds on top of that in entirely the wrong direction, and brings out
the worst of it.

ABS

--
Alaric Snell-Pym
Work: http://www.snell-systems.co.uk/
Play: http://www.snell-pym.org.uk/alaric/
Blog: http://www.snell-pym.org.uk/?author=4