The Art of Lisp and Writing (2003)

by enduser • 13 years ago

76 34 13 years ago

enduser7• 13 years ago

Choice quotes:

"Lisp is a medium for working with a computation until it is in balance with its external and internal requirements. At that point it can be decorated with performance-enhancing declarations and perhaps additionally modularized. In this it is more like an artist's medium than what many think of as a programming language."

"Writing a beautiful text takes sitting before a medium that one can revise easily, and allowing a combination of flow and revision to take place as the outlines and then the details of the piece come into view. Changes are made as features of the writing emerge—first the noise, then the sense, the force, and then the meaning—and the work of the writer is to continually improve the work until it represents the best words in the best order. Great writing is never accomplished through planning followed by implementation in words, because the nature of the word choices, phrasings, sentence structures, paragraph structures, and narrative structures interact in ways that depend of each other, and the only possible plan that can be made with which a writer can "reason" about the piece is the piece itself."

"The difference between Lisp and Java, as Paul Graham has pointed out, is that Lisp is for working with computational ideas and expression, whereas Java is for expressing completed programs. As James [Gosling] says, Java requires you to pin down decisions early on. And once pinned down, the system which is the set of type declarations, the compiler, and the runtime system make it as hard as it can for you to change those assumptions, on the assumption that all such changes are mistakes you're inadvertently making. There are, of course, many situations when making change more difficult is the best thing to do: Once a program is perfected, for example, or when it is put into light-maintenance mode. But when we are exploring what to create given a trigger or other impetus—when we are in flow—we need to change things frequently, even while we want the system to be robust in the face of such changes."

Jimmy2• 13 years ago

"The difference between Lisp and Java, as Paul Graham has pointed out, is that Lisp is for working with computational ideas and expression, whereas Java is for expressing completed programs. As James [Gosling] says, Java requires you to pin down decisions early on..."

My experience with modifying Lisp and Java programs has largely been the opposite. I've been working on a Java application for the past few weeks, and the design of the program has changed several times as I've thought of new features to add and cleaner ways to organize my code. Today, I had a class X that was responsible for keeping track of a certain variable, and I wanted to move that responsibility to class Y. I deleted the relevant field and all references to it in class X, and Eclipse highlighted all of the errors that change introduced. I fixed the highlighted errors and added the new methods I needed to class Y, and when I tested the relevant functionality, I saw that I had introduced only one minor bug, which I fixed with a single line of code. There was nothing difficult about the process.

I've found refactoring Lisp programs to be more difficult. When I was writing a prototype of this same application in Lisp (Clojure more specifically), I had a macro to implement a small DSL. The macro was not particularly complex, although it was non-trivial: it did some code walking and called some helper functions. When my DSL grew past a certain size, making changes to its implementation became rather difficult. Sometimes the compiler would report errors at runtime, but more often than not, things would just stop working in mysterious ways whenever I made a change. The macro's output was also quite different than the kind of code I would write by hand, so debugging was difficult.

I'm not the best Lisp programmer, so I'm not trying to say that Lisp always makes it hard to change your programs. But there are cases where Java makes it very easy to change your programs.

enduser7• 13 years ago

Tooling around Java (e.g. Eclipse) has developed significantly since the time this article was written. If you're working in programs where the system is too big to fit in your mind, good tooling certainly helps. Lisp is especially powerful for programmers who are able to work with large and complex mental models of systems.

and

Debugging Lisp in Lisp is far superior (easier) compared to debugging Lisp in Java (which is what you get when you use Clojure). Clojure has been getting a lot of press as being the rebirth of Lisp, and it includes some useful paradigms in the core language, but it is woefully incomplete as a full Lisp development system when compared to mature Common Lisp implementations.

seanmcdirmid5• 13 years ago

As someone who writes academically and writes code in the form of research prototypes, I really have to disagree to some extent with RPG and PG. Code is code, it doesn't have to be elegant, it doesn't have to be read, and using a less elegant language (like say C#) can be liberating compared to one where more elegance is possible (say Scala). The architecture you are working on floats around in your head regardless, becoming more beautiful, and the language that it is expressed in is just a detail...it is easy enough to throw the code away and start again once it becomes too unwieldy and you need to take your design to the next level.

But then RPG also wrote "worse is better."

enduser7• 13 years ago

Common Lisp was designed for large, complex applications where it is not "easy enough" to throw code away but existing codebases must be evolved in-place. It is a practical language, not an academic language.

In academia, your code is a reflection of your conception and can be changed when the conception changes.

In the "real world" the satellite you already launched into orbit needs a new feature.

klibertp• 13 years ago

As someone who writes academically [...] code [...] doesn't have to be read [...] it is easy enough to throw the code away and start again

That pretty much sums up the difference between academia and the so called "real world".

michaelwww5• 13 years ago

"Lisp is the language of loveliness. With it a great programmer can make a beautiful, operating thing, a thing organically created and formed through the interaction of a programmer/artist and a medium of expression that happens to execute on a computer."

It's this kind of statement that makes me suspect Lisp is not very practical. I'm not programming for the sake of programming to create something that "happens to execute on a computer." There are other artistic endeavors for my free time that are more interesting than a lovely computer language.

enduser7• 13 years ago

That's like saying that a walker allows you to traverse a floor more "practically" than dancing.

michaelwww5• 13 years ago

So in your estimation all other computer languages are walkers compared to the beautiful dance of Lisp? I'm curious, maybe I really do need to learn Lisp.

jbooth2• 13 years ago

If my goal is to get across the floor, I'd prefer a brisk walk.

dschiptsov• 13 years ago

Ignorance more frequently begets confidence than does knowledge. such a good summary of Java (and now Javascript) madness.)

The Art of Lisp and Writing (2003)

Related Stories