do...until wisdom needed...

[Douglas Alan]

"Alex Martelli" <aleaxit at yahoo.com> writes:

>> 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,

Not to mention Lisp.

> 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.

I don't expect that dynamically typed languages will be the mainstream
for large development projects anytime real soon.  My own experience
agrees with the mainstream wisdom that static typing greatly increases
reliability and greatly decreases debugging time.  Of course there are
very distinct costs associated with these benefits, and because of
them I curse C++ endlessly, despite the fact that it has saved me from
a life sitting in the debugger.

Perhaps Extreme Programming will take over the world and prove the
current orthodoxy wrong.  I tend to doubt it, but I've been wrong
before.  My feeling is that someday we'll have languages that combine
most of the benefits of dynamic languages and static languages, and
that these languages will win out in the end.

>> 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).

The budding entrepreneurs, I imagine, typically want to use languages
where there is already a constant and voluminous supply of programmers
that are highly trained in the language and who are clammoring to use
it.  This is not the case for Lisp -- even I who love Lisp was not
clamoring to use it, for the reasons I mentioned previously.

In other words, these sorts of decisions are often made based on
"buzz" and "momentum", rather than on the real merits of the languages
in question.

> 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.

I imagine that the benefits of Unix versus Windows are significantly
more apparent than the benefits of Lisp versus Java.  Also, with OS'es
there are only two real choices, while with languages there are many.
When the choice of an alternative is very clear, it makes it easier to
chose the alternative.

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

> [...]

> 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.

The problem with Scheme is that it is too cold, and the problem with
Common Lisp is that it is too hot, and the dialect that is just right
(i.e., "T") is too obscure.

Also, even though Common Lisp is too hot (i.e. too big and bloated
like PL/1), it doesn't include the tools (not to mention the
footprint) that Python comes with for writing all the little scripts
that you want to write to make your life easier.  Common Lisp is tuned
for writing big hairy applications, but not for writing tiny little
handy tools.  That Python is remarkably well tuned for this is what
gets its foot in the door.

> 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?

I wrote more on this in another recent message of mine.

> 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

That's certainly true.  Scheme was originally tuned for teaching and
research -- not for writing large apps.  A standardizing committee was
formed to make it into a useful language, but they didn't want Scheme
to be broken by design-by-committee-itis the way that perhaps Common
Lisp is, so they insisted that all decisions be unanimous.
Consequently, nothing ever got decided and the language barely grew
beyond its original research and teaching aspirations.

Almost all dialects of Scheme added their own non-standard features in
order to make them more useful, but, being non-standard, actively
using these features must be considered problematic.  "T", which came
from Yale, was a particularly useful and well-designed dialect that
extended Scheme.  It wasn't too big, and it wasn't too small.  It was
about the complexity of Python, more or less.  But competing with
other dialects of Lisp and Scheme it never caught on in a big way.
Also, it wasn't well-tuned to writing those little scripts that Python
is so good at.

>  -- 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

That's certainly true, since Scheme is to Common Lisp as Algol is to
PL/1.  The transition to T would have been pretty smooth....

|>oug