TITLE: "A Pretty Good Lisp"
AUTHOR: Eugene Wallingford
DATE: October 31, 2011 3:47 PM
DESC:
-----
BODY:
I occasionally read or hear someone say, "X is a pretty good
Lisp", where X is a programming language. Usually, it's a
newish language that is more powerful than the languages many
of us learned in school. For a good example, see
Why Ruby is an acceptable LISP.
A more recent article,
Ruby is beautiful (but I'm moving to Python)
doesn't go quite that far. It says only "almost":
Ruby does not revel in structures or minutiae. It is flexible.
And powerful. It really almost is a Lisp.
First, let me say that I like both of these posts. They tell
us about how we can do functional programming in Ruby,
especially through its support for higher-order functions. As
a result, I have found both posts to be useful reading for
students. And, of course, I love Ruby, and like Python well
enough.
But that's not all there is to Lisp. It's probably not even
the most important thing.
Kenny Tilton tells a story about
John McCarthy's
one-question rebuttal to such claims at the very end of his
testimonial on adopting Lisp,
Ooh! Ooh! My turn! Why Lisp?:
... [McCarthy] simply asked if Python could gracefully
manipulate Python code as data.
"No, John, it can't," said Peter [Norvig] and nothing more...
That's the key:
data == program.
It really is the Big Idea that sets Lisp apart from the other
programming languages we use. I've never been a 100% full-time
Lisper, and as a result I don't think I fully appreciate the
full power to which Lisp programmers put this language feature.
But I've programmed enough with and without macros to be able
to glimpse what they see in the ability to gracefully manipulate
their code -- all code -- as data.
In the "acceptable Lisp" article linked above, Kidd does address
this shortcoming and says that "Ruby gives you about 80% of what
you want from macros". Ruby's rather diverse syntax lets us
create readable DSLs such as Treetop and Rake, which is one of
the big wins that Lisp and Scheme macros give us. In this sense,
Ruby code can feel generative, much as macros do.
Unfortunately, Ruby, Python, and other "pretty good Lisps" miss
out on the other side of the code-as-data equation, the side
McCarthy drew out in his question: manipulation. Ruby syntax is
too irregular to generate "by hand" or to read and manipulate
gracefully. We can fake it, of course, but to a Lisp programmer
it always feels fake.
I think what most people mean when they say a language is a
pretty good Lisp is that it can be used as a pretty good
functional programming language. But Lisp is not only an FP
language. Many would claim it is not even primarily
a functional programming language.
I love Ruby. But it's not a pretty good Lisp. It is a fine
programming languages, perhaps my favorite these days, with
strengths that take it beyond the system programming languages
that most of us cut our teeth on. Among those strengths are
excellent support for a functional programming style. It also
has its weaknesses, like every other programming language.
Neither is Python a pretty good Lisp. Nor is most anything
else, for that matter. That's okay.
All I ask is this: When you are reading articles like the ones
linked above, don't dismiss every comment you see that says,
"No, it's not, and here's why" as the ranting of a smug Lisp
weenie. It may be a rant, and it may be written by a smug Lisp
weenie. But it may instead be written by a perfectly sane
programmer who is trying to teach you that there is more to
Lisp than higher-order functions, and that the more you've
missed is a whole lot more. We can learn from some of those
comments, and think about how to make our programming languages
even better.
-----