Why is Python popular, while Lisp and Scheme aren't?

[Kenny Tilton]

Alexander Schmolck wrote:
> Kenny Tilton <ktilton at nyc.rr.com> writes:
>>Puzzled. "scale well" to me means "what happens when you try to use it for a
>>big project" or possibly a small project with big runtime resource
>>requirements. CL is great at either, precisely because it can do a lot.
> 
> 
> 
> "Scale well" normaly implies up, but what I mainly meant is that CL doesn't
> scale down well in a couple of ways. One factor are users: CL is a poor
> language for people who don't have, X (say 18) months or so of time to spare
> to learn CL (which includes pretty much everyone except people who want to
> program professionally in CL or language afficados).


> This initial investment is unlikely to be made even by many professional
> programmers who might well profit from using CL, let alone normal users who
> just want to customize their applications, or scientists who need to do a bit
> of programming to handle their data.

Gotcha. well to me this is more about the many libraries available off 
the shelf for Python or Perl thx to the great open source phenomenon, 
not about CL being harder to learn.

> I really wonder what your basis for thinking CL to be very approachable
> is. Specifically, what language(s) do you think would be *less* approachable
> to a "normal" person than CL? Even perl, which is hideously complex (unlike CL
> which is complex, without being hideous), is more approachable in that you can
> do something worthwhile without learning much about Perl ...

Again this is because of the library code available, yes?

> How about the following criteria for approachability of a language:
> 
> 1. it should be easy to do conceptually simple and common things
> 2. it should be easy to do something useful with it
> 3. it should be easy to read other peoples code
> 4. it shouldn't have too many surprises in store (e.g. undefined behavior)
> 
> I think CL fails on all these criteria, for example:
> 
> 1. operations on files and directories.

I don't deal much with that sort of thing in my apps, but I did do a 
poor man's project manager for a CL (before I got up to speed on 
DEFSYSTEM) and I do not recall any problem If Python has a lot of that, 
is that because it was developed for that kind of thing?

> 2. try to write something in 1-100 lines in CL that couldn't easier be
>    written in e.g. python.

I am guessing you mean something where the Python programmer would be 
able to call on libraries? Mind you, I am just getting started on 
Python, but CL can do quite a bit in a little code if you are just 
talking algorithms. Maybe we should have a code-off (ala cook-off). :)

> 3. just think of how many ways there are to express quite similar
>    conditional or looping constructs.

You mean if, when, and cond? when you can ignore, tho most of us 
consider it more self-documenting. cond is just if-elseif-if.

Dolist, dotimes, and the multi-variant do? I don't use Loop, but I think 
I'll break down (after seven years!) and learn it RSN.

Anyway, is a rich language less approachable? I just started with a 
subset and was productive right away (meaning that as I learned more I 
had a laugh looking at code written in the early days).

> 4. try e.g. modifying constant lists or writing a LOOP with undefined
>    behavior, or modifying the (string) keys in a hash-table.

So use C++ and you won't shoot yourself in the foot (or get much done 
either <g>)

By approachable I mean:

   the syntax is very simple: (<verb> noun noun ...)

   interactive (I would say interpreted but in fact some CLs silently 
compile interactive forms and execute the binary)

   documentation available at a keystroke, and apropos to search for 
stuff you suspect is in the language

   true garbage collection (I am /not/ looking forward to reference 
counting or the hoops one has to jump thru to handle cyclic refs)

   untyped variables

Stuff like that. But I am just talking about the language per se, not 
what libraries are available off the shelf. I lean, Lisp is growing, 
libraries will follow. It's a bootstrapping process: more Lispers -> 
more libraries -> more Lispers. And that /will/ be welcome.


-- 

  kenny tilton
  clinisys, inc
  ---------------------------------------------------------------
""Well, I've wrestled with reality for thirty-five years, Doctor,
   and I'm happy to state I finally won out over it.""
                                                   Elwood P. Dowd