
Interviews with Lisp Hackers: Pascal Costanza - fogus
http://lisp-univ-etc.blogspot.com/2012/04/lisp-hackers-pascal-costanza.html
======
agentultra
_What concerns me a lot more is that there is too much unwarranted arrogance
in the Lisp community. I don't know exactly where this comes from, but some
Lispers seem to believe, just because they understand some Lisp concepts, that
they are much smarter than anybody else in the universe. What they are
forgetting is that computer science as a discipline is very, very young. In
one or two hundred years from now, Lisp concepts will be common knowledge,
just like elementary algebra. There is no reason to be arrogant just because
you know that the earth is round, even if most other people still believe that
it is flat._

I'm not sure I've experienced this "arrogance," but I've heard so many people
talk about it or try to explain it that I suppose it must exist in some shape
or form.

Either way, I thought this bit of advice was rather insightful and prudent. It
doesn't just affect the Lisp community either mind you. In my experience
anyone who is ignorant enough to believe they are smarter than someone else by
virtue of what they already know is easily led into this sort of thinking...
and it's a train of thought that is worth worrying about for those of us who
are interested in fostering positive communities with valuable contributors.

~~~
bmj
I thought his comment was insightful, too, until I read the last line. Then it
just sounded like arrogance. I suppose I read a positive spin on that comment
--something like "well, most people just haven't discovered the facts about
how great LISP really is," but the round/flat earth analogy doesn't
necessarily foster such a reading.

~~~
bgilroy26
I can see it that way now that you mention it, but when I read it initially, I
gave it a more charitable reading.

It's possible that Mr. Costanza means by "not arrogant" that it isn't a reason
to think that you're better than the flat earther _at all_. There are plenty
of people for whom knowledge of the curvature of the earth does not often come
into play. It isn't out of the question that Mr. Costanza means that those
folks could learn about the shape of the earth if it came up, and that the
fact that it hasn't come up for them is a matter of circumstance rather than
in-born ability.

------
zephyrfalcon
"""But Common Lisp is so flexible that at every stage in your development, you
can tweak and twist things left and right, but in the end you still get a
convincing, clean, and efficient design. As far as I can tell, this is not
possible in any other language (not even Scheme)."""

Of course, this kind of begs the question... why not in Scheme? Considering
it's part of the Lisp family as well, what makes CL more flexible? (Taking
into account that "Scheme the language", as based on R5RS, R6RS, etc, is
limited; but a particular Scheme implementation might have everything & the
kitchen sink.)

~~~
pwpwp
CL, and its object system particularly, specifies a lot of extensibility and
sometimes hilarious dynamicity with exacting detail. E.g. you can subclass a
class that doesn't even exist yet (!)

    
    
      CL-USER> (defclass foo (bar) ())
      #<STANDARD-CLASS FOO>
      CL-USER> (find-class 'bar)
      #<FORWARD-REFERENCED-CLASS BAR>
    

That's just one detail, but CL is _chock full_ of such niceties, owing to the
fact that a lot of rivaling factions of super-smart programmers wanted to get
all their favorite features into it.

~~~
lisper
Reader macros are also very handy. This is a feature unique to CL.

~~~
zephyrfalcon
That doesn't seem correct. I know of at least two Scheme implementations that
have reader macros (Racket and Chicken); there might be more. However, whether
their reader macros are as powerful as CL's [1], I don't know.

[1] as demonstrated e.g. here:
<http://letoverlambda.com/index.cl/guest/chap4.html>

~~~
lisper
These are implementation-specific extensions, not part of Scheme. Scheme
doesn't have e.g. a GUI either (neither does CL) notwithstanding that specific
Scheme and CL implementations have GUIs. It's borderline trivial to add reader
macros to any implementation of any dialect of Lisp, but only in CL can you
count on having them available.

------
keithflower
Brilliant fellow, and Pascal is also a genuinely kind human being. He
responded thoughtfully and in detail to several questions I posted to
comp.lang.lisp about some arcane ideas around reflection. On numerous
occasions he's tried to patch things up between members of the Lisp/AI
community. He's gone out of his way to help people in many other ways.

------
emmelaich
(since no-one else has commented ..) Nice to read; I'm always impressed with
his postings on lisp from the very limited exposure I've had. (contrast with a
certain other ...)

Also nice to see a mention of Xlisp, which first appeared in the pages of Byte
magazine a million moons ago. Fond memories of playing with it on an Amiga.
Website: <http://www.xlisp.org/>

------
kinleyd
A very nice interview with Pascal Costanza. It was good to know he does all
software prototyping in Lisp, though I wish he could have taken it into
implementation as well. Still, I'm already sold on Lisp, and this interview
gave me a number of additional reasons for remaining so.

~~~
yvdriess
Oh his scheduler implementation is completely in Lisp. It's just that they
needed to make a C++ version due to the research context they are working in.
Not a very uncommon problem for Lisp users.

------
orthecreedence
A very nice read from someone who's passionate about Lisp. The take-away I got
was the mention of ISLISP (<http://www.islisp.info>) which I didn't previously
know about. From the site, it seems to try to bridge the gap between a lot of
different Lisp variants while focusing on real-world application (as opposed
to academia). Worth checking out.

Thanks for the interview!

