Choosing a programming language as a competitive tool

Patrick Wray pwletterbox at yahoo.com.au
Sat May 5 18:27:11 CEST 2001


"John Markus Bjorndalen" <johnm at cs.uit.no> wrote in message
news:hvelu4xarw.fsf at johnmnb.jmbnet...
> "Steven D. Majewski" <sdm7g at Virginia.EDU> writes:
>
> >   And I was arguing against Courageous' description of Lisp as
> >  difficult: despite that personal-fudge-factor cited above, there's
> >  NO WAY you can say that Lisp is an order of magnitude more difficult
> >  that other stuff -- Java, C++, Perl -- that are widely used, so the
> >  argument that Lisp doesn't get used because it's inherently difficult
> >  to learn doesn't hold water. ( And if it does seem difficult to some
> >  folks it probably, it's more likely a problem with how it's taught
> >  than the language itself. )
>
> My belief is that one of the reasons people can find it hard to learn
> Lisp is that many of the Lisp books expose you to multiple programming
> paradigms and ways of thinking of code that might not be common (or at
> least commonly used) in other languages.

Pretty close, I think.

I don't think the main concepts underlying Lisp are especially difficult to
grok. They're certainly unusual (at first) if you're coming from a typical
procedural/imperative/OO background - but I don't think that's such a big
deal. (It shouldn't be anyway. That's what learning a language is all
about).

If people have difficulty learning Lisp, it's probably also partly as a
result of the problems that Lisp has traditionally been used to solve.
Reading code and understanding syntax is one thing; understanding the intent
is quite another. "Difficulty" depends on the complexity of the intent as
well as the complexity of the language.

I guess I subscribe to (a slightly watered down version of) the Whorfian
hypothesis - that languages especially artificial languages) have a strong
effect on what we are able to think. Lisp is difficult, not because it is
complex in itself, but because it provides good mechanisms to express very
complex thoughts, and Lisp has been used for this purpose for decades by the
best and brightest minds in the field. (As you suggest, most Lisp books
aren't of the "learn <whatever challenging craft> in 24 hours" variety).

I think the difficulty of learning, say, Perl or C++ stems from quite
different causes. The _languages_ are complex, but they are _syntactically_
tricky rather than _conceptually_ mindbending. (That's not to say that Perl
and C++ aren't used by brilliant people for amazing purposes; my point is
that the difficulty of learning them arises from different causes).

IMO, when Lisp is used for simple purposes (and why not?), it's MUCH easier
than C++ or Perl because there's nothing between the intent and the
expression. No housekeeping crap. You can hack up a working prototype in a
fraction of the time, and use all the time you've saved by refactoring, if
need be.

Regardless of whether or not it's "difficult to learn" (or whether there's
any reliable measure of that apart from subjective experience), I think
anyone who's interested in programming languages can learn a lot from Lisp.
It contains the roots of just about every good and interesting feature of
other languages - and 40 years on it's still more advanced than any 'modern'
alternative (AFAIK).

I don't know how much Guido was influenced by the Lisp family when he
designed Python but, to me, working in Python _feels_ very much like working
in Lisp. I consider that a marvellous achievement on his part.

> The trick is knowing when you struggle with a concept and when you're
> really struggling with the language.

Exactly!






More information about the Python-list mailing list