do...until wisdom needed...

[Alex Martelli]

"Douglas Alan" <nessus at mit.edu> wrote in message
news:lcy9s8n4nf.fsf at gaffa.mit.edu...
> "Alex Martelli" <aleaxit at yahoo.com> writes:
>
> > Inertia of existing organizations, do I hear?  Then why didn't Lisp
> > or Scheme dominate among the no-legacy-code startups that mushroomed
> > in the late '90s?
>
> As a Lisp and Scheme lover I think I can answer this question.  Lack
> of strong type-checking is now typically considered a major impediment
> to large programming projects.

This is a typical attitude in certain circles, yes, but,
considering the size of systems being put together in
Erlang, in Smalltalk, in Python, or even in Tcl, Perl,
Javascript, it seems that static compile-time type-
checking (which I assume is what you mean here by
'strong') is perceived otherwise in many other circles,
and it seems to me that at this time the circles that
are getting wider are these 'other' ones.

> Also, I never pursued a Lisp
> programming career, because I didn't want to get stuck in what I
> perceived would be a ghetto.  I've already committed myself to the

I was thinking more of the many budding entrepreneurs, many
of them CS types of various sub-ilks, that were behind the
manifold flowering of startups in the late '90s -- people
who presumably thought in terms of competitive advantage
against other enterprises, rather than of "career".  What
programming languages were they typically betting their
budding firms on?  Java, scripting languages, C and C++,
in roughly decreasing order, it would appear (no systematic
study I know of -- just a general impression gathered from
reading and discussions over the years).

I'm not really interested in whether their bets were in
fact successful or not (as it seems over 80% of those
startups have folded by now, "not" seems to be it, but
how relevant a specific choice such as a programming
language would be for that, as opposed to business
model issues, financial ones, etc, is quite moot:-),
but, rather, why they bet the way they did -- rather
than inspiring a Lisp resurrection...

You also mention Unix as a ghetto, like LISP -- and
Unix (particularly in variants such as Linux or free
BSD ones) DID play a significant role in many of the
startups (I heard, and this did purport to be a kind
of systematic study, that Linux had the highest growth
rate of any OS during the peak of the startups boom).
The perception of competitive advantage WAS there in
this case, apparently.

Unix is also an example of a technology that DID move
from marginal to front-line status in good part thanks
to being used in academia -- people who had grown used
to Unix as students were generally keen to keep working
on Unix rather than switching to purportedly "friendlier"
OS's such as Microsoft's.  And I do understand that --
having been mostly on MS boxes for the last five years
or so, I look forward eagerly to the day when I can
finally be working with a modern Unix-like OS again.

But why don't I feel the same way towards Lisp...?

When I had to design a language (BBL, the Bridge
Bidding Language) I had no doubt choosing Lisp-ish
surface syntax for it -- but that was because I knew
the main "users" of the language would be other
programs (including macros)... GUI front-ends to
generate "programs" (describing bridge hands to be
considered suitable for certain sequence of bids),
other programs to make use of the generated BBL
ones (generate random hands suitable for a given
sequence, etc).  But after a little prototyping in
a Texas Instruments version of Scheme (at the time,
as I recall, the only one I could find that ran
really well on a typical PC), I switched to other
implementation languages for the BBL generators
and interpreters (took the occasion to teach myself
Modula-2, which I had not previously had occasion
to use in earnest -- a pretty good new PC-sized
implementation thereof having just come out at the
time).  _Reasoning_ in Scheme terms came easy to
me, but for actual day-in, day-out development it
just didn't "jell" -- and I still wonder why.  It
surely was not an issue of "career" choices, as BBL
was a typical "hobby" effort, part of my interest
in personal research about contract bridge.


> Another reason is that CS courses taught in Scheme are typical very
> mind-bending and deep.  Many people don't like to have their mind bent
> that deeply, and thus will be resentful of Scheme to their dying day.

An interesting thesis.  Personally, I consider SICP to
be the number-one reason to recommend learning Scheme.
But I think I do understand what you're saying about
"people who don't like to have their mind bent".

> The bending of their minds was good for them, nonetheless.  People
> such as I who love to have their minds bent, on the other hand, end up
> loving Scheme and the way they were taught CS.

Me, I have nothing but respect for Scheme (and Common
Lisp, for what little non-really-applied understanding
I have of it; it strikes me as complicated in a way
Scheme isn't, but that might possibly be a consequence
of not having "used it in earnest") -- but still I find
myself not really moved to use it for production work,
the way I feel for Python.

I don't really understand why, and part of my wondering
why so many other people (who were exposed to it in their
CS studies, if Scheme is indeed widely used in teaching
CS) appear to feel similarly, was to try and gain more
clarity on my own reasons.  But surely, if "resentful of
Scheme" is a widespread issue, that's not the one that
applies to me.

IS it widespread?  Is the _typical_ CS student, who was
taught a CS course in Scheme at some institution of
higher learning, of the "don't like to have their mind
bent" persuasion, to the point of feeling "resentful
of Scheme"?!?  Seems a doubtful hypothesis to me -- do
others who know typical US CS graduates first-hand have
a more informed opinion?

Alternative hypotheses might be entertained.  Maybe
Scheme isn't as widely used in teaching as all that --
what % of first CS courses use it?  Maybe Scheme can
be perfectly suited to teaching and exploration but
not as useful for production use -- the way a richer
but more complicated tool such as Common Lisp might
be -- and perhaps the Scheme -> Common Lisp transition
may not prove as smooth for many as just describing
both as "dialects of Lisp" might suggest (as we've
seen both Python and Haskell described in similar
terms in these threads, the tag might possibly carry
relatively little real-world usefulness, at least as
it's being used around here these days).  I'm not sure
there ARE real-world lessons to be learned from all
this, but, I still wonder...


Alex