
Anyone who knows how to program in Lisp is smart. - bsaunder
http://occamsoftware.blogspot.com/2007/04/anyone-who-knows-how-to-program-in-lisp.html
======
whacked_new
You gave yourself too much leeway in the insert, "(and I mean really
program)." Whoever fits that clarificaiton, is smart.

Lisp is a language. A language is a tool. If you can use a tool to build great
things, you are good. Perhaps your tool is not for the weak-minded, but
wielding a tool is not enough to say anything. A three section staff requires
godly dexterity, but is inferior to the longsword in combat. The latter is
easier to pick up and thrash around, but way more difficult to master.

I feel like saying this because anybody who programs is likely to be able to
pick up a new language and play around with it; the premises are the same.
Anybody who speaks can likely pick up a new language and make sentences. You
might find, say, the subject-object-verb ordering particularly intersting and
conclude anyone who speaks Japanese is smart -- but it's more about practice
and application.

If you decompile your mind it's probably half spaghetti code. If you decompile
Feynman it'd probably be strangely productive infinite loops of sorts.

~~~
ecuzzillo
I wouldn't say that anybody who programs is likely to be able to pick up a new
language easily. Anybody who has been exposed to most of the common ways of
thinking about programming (functional, logic, the various subsets of OO,
imperative) can probably pick up a language that uses any of those pretty
easily (it's basically just syntax from there). Similarly, someone who knows
both Chinese and English can probably pick up French pretty easily, because
their tools for thinking about languages are expanded enough that picking up
another one doesn't involve significant restructuring.

However, if you take someone who programs in Basic, and try to teach them
Lisp, it will take them a long time, because there are lots of new concepts to
learn. Similarly, if you take an English speaker and try to teach them
Chinese, there will be a lot of stuff to learn, and it will take a long time.

~~~
whacked_new
Valid point. But also look at it this way.

An English speaker who has mastered Japanese will have gone from an SVO
(subject verb object) language to an SOV language (Chinese is not as
convenient an example, because it is also SVO). This is a completely different
"paradigm of thinking," just for the comparison. Your brain needs to sort the
order of concepts before your initiate your utterance. You need to match
particles to their respective concepts. For anybody who never learned such a
system, it doesn't come easily. But those who have gone to a sufficient level
will become more perceptive of the nuances and particulars of "language" as a
whole. This knowledge is far less accessible to those who only know one
language. A linguist who only speaks one language will not be taken seriously.

Similarly, a competent programmer is likely to be versed in several languages,
and likely they will fall into different paradigms. A programmer who only does
LISP is likely to not have the same level of knowledge about the computer
system than one who knows several languages. After all, you are looking at
multiple ways of generating 1s and 0s. As such, knowing LISP certainly cannot
imply anything. Of course, the author anticipated this response, and added a
loophole in the article, which I consider a bit too wide, hence the criticism.

There are visible reasons why LISP trains your thinking. My post above is
pretty poorly written, but the reference to spaghetti code is like the BASIC
example you mention. Supposedly, good programming practice discourages
spaghetti code, and BASIC was taken as the bad example. But people think in
spaghetti code. If you pry open von Neumann's brain, it would probably be
uber-spaghetti code. It would probably decompile into something more BASIC-
like than LISP-like, but he's insanely smart.

Yes, it's the logic training. But if that was the theme, the article should
have addressed it clearly. I just felt like pointing out how the current topic
in the blog does a rather weak generalization, which helps more to propagate
misconceptions than it does to educate.

~~~
bsaunder
First of all, thanks for the constructive criticism. This is my first blog
article, so I'm begining to realize the sensitivity of carefully wording
things.

With regards to my constraint "(and I mean really program)", I merely wanted
to exclude those people who claim to "know about" LISP, or who are not
competent in LISP (and I think I have a weaker threshold for competent than
you).

I guess I tend to disagree with your statement:

"Similarly, a competent programmer is likely to be versed in several
languages, and likely they will fall into different paradigms."

I think "a competent programmer" is a low bar (70 percential?). I don't think
it's true that competent programmers are likely to be "competent" in several
languages that fall into different paradigms.

Also, I feel like LISP's paradigm is so far removed from most others (and with
arguably a superset of concepts), that any programmer who is competent in LISP
_IS_ likely to be competent is several other languages that span different
paradigms. Agreed if there exists one programmer out there who _ONLY_ knows
LISP, they lack the complete conceptual understanding I'm asserting.

It seems to me that programmers who tend to write spaghetti code and/or over
complicate matters will abandon LISP out of fustration before they achieve
"competency in LISP".

The point of the article was to assert that "competency in LISP" implies much
more than "competency in LISP" and that this statement is not true of most
other programming languages.

Sorry you feel this article propagated misconceptions, I'll try to do better
next time.

~~~
whacked_new
Apologies if I came off as too aggressive. I guess you can say that the title
-- which at face value made a fairly daring statement -- primed my critical
attitude, like many bloggers had to pg's "MS is Dead" article. I may very well
have overreacted, so don't take my words too seriously. Clearly you didn't
write the article to start flamewars; I could just be an instigator who tries
to sound coherent.

Great to hear feedback though, and you found a weakness in my argument. My
preconceptions of a "competent programmer" are often based on qualities I wish
I had :)

------
ralph
I don't think it's knowing Lisp in particular that's valuable, but
understanding different paradigms.

Lisp's paradigm is sufficiently different from the normal imperative
languages, e.g. C or Python, that grokking Lisp means you understand more than
one paradigm. It's this that's valuable, not knowledge of Lisp itself.

You often find that coders who know multiple paradigms will write interpreters
for little languages in the implementation language available to them in order
to better represent the problem, rather than attempting a dumb implementation
in the bare implementation language.

There used to be a good book by Sam Kamin, _Programming Languages: An
Interpreter-Based Approach_. It examines cut-down versions of different
languages, e.g. Lisp and Prolog, implementing an interpreter for each of them
in an imperative language to help explain how they work. Norman Ramsey was
working on an update but I don't know if it's been published yet. Some
universities seem to have access to a pre-release:
<http://www.cs.uml.edu/~dimock/courses/languages/Spring2005/mainpage.html>
(Disclaimer: I provided review comments to Ramsey for a couple of chapters
back in 2002.)

Where Lisp is useful, is that just about any paradigm and his dog can be
implemented in Lisp.

~~~
bsaunder
"Lisp's paradigm is sufficiently different from the normal imperative
languages, e.g. C or Python, that grokking Lisp means you understand more than
one paradigm. It's this that's valuable, not knowledge of Lisp itself."

This was exactly my point... grokking Lisp is a hallmark of intelligence. I
don't think there is any other programming language that rises to this level.

~~~
ralph
What other languages do you think don't rise to this level?

~~~
bsaunder
Let me reconsider (I had forgotten about Paul Graham's, Python article). I
suspect there are other langauges (not many) that reach this same level of
intelligence tagging.

I think the second paragraph of his Python article captures much of my intent.
But still, there seems to be something just a bit different about LISP than
most other langauges.

Perhaps it is LISP's durribility or the fact that over time different (smart)
people develop new lanuages and eventually begin to incorporate more and more
features of LISP. LISP clearly got some things right in a fundamental way that
every one seems to be rediscovering every decade. This leads me to believe
that if you understand LISP, you have a deeper understanding of how things
really fit together.

With specific regards to your question, I'd include most main stream
programming languages (but that's kinda obvious). At this point, I'd include
Ruby in this list, but may not Python. Although even in the case of Python, it
strikes me as being very similar to other OO languages (better perhaps, but
similar none-the-less).

------
Goladus
"If only Paul Graham could have been writing 10 years ago instead of starting
a company ;)"

Seriously... When I used Lisp in college I remember thinking that it felt like
cheating. It felt like using a graphing calculator to solve polynomials in
high school. The only other languages I'd used in class were C, C++, Java, and
68K assembler, and it was hard to shake the idea that serious programming was
supposed to be painful and low-level.

------
shiro
I write Lisp/Scheme for living, but I'm not sure I can make such a bold
statement (esp. how Lisp compares to other functional/logical languages---they
do require different paradigm).

But I can tell one thing from my experience: All competent Lisp programmers I
know are also pretty good at C, C++, Java, or even Assembly. Even if they
don't initially, they quickly become good. So, in empirical sense, using Lisp
as one filtering factor can work. (But be aware: The fact that they can write
good Java code doesn't mean they want to do so).

------
pg
Probably, if only for the same kind of reasons that tends to be true of Python
or Ruby: <http://paulgraham.com/pypar.html>

------
gyro_robo
"I tried to learn Chinese and it was super hard! Anyone who can speak Chinese
must be smart!"

~~~
pg
Except no one is a native speaker of a programming language.

The more valid comparison might be "Anyone who can speak Latin must be smart,"
and that is probably not far wrong.

~~~
vlad
Maybe, anybody who knows how to use a dictionary to translate one word to
another is smart.

Because if you simply "know" a language, it means nothing unless you quantify
some experience behind that simple awareness of the language syntax.

A lot of people say they "know", when they mean "know about."

~~~
gyro_robo
I know about Lisp.

