Why I love Common Lisp and hate Java

http://kuomarc.wordpress.com/2012/01/27/why-i-love-common-lisp-and-hate-java/

by swannodette • 14 years ago

54 52 14 years ago

kuomarc.wordpress.com

gatlin• 14 years ago

This feels like a lot of blog posts I write: the main content is probably there, in the author's head, but not enough of it was put on the paper. What we read instead is a slice of what I have no doubt in my mind to be a fantastic essay.

I have recently begun a love affair with Racket and for a reason I think that the author was ultimately trying to get at: the core syntax of any Lisp is a minimalist tree and the semantics are lambda calculus (and abstract algebra to help motivate types).

An REPL for Java could conceivably be written; AI is language agnostic; and plenty of languages let you eval generated code; but Lisps are a window into computation itself and it's very addicting.

hendzen• 14 years ago

BeanShell is basically a Java REPL.

Deinumite• 14 years ago

Any time I see someone complaining about how much effort it is to "just print a string to std out in java" it boggles my mind.

Java was not really designed for ease of use in that way, clearly, and the syntax and vm itself heavily lends it to networked programming.

This post would be better if it was "Why I love Common Lisp" with the half hearted stabs at Java taken out of it.

koko7752• 14 years ago

Seriously. I've been doing Java for years and it had been so long since I wrote public static void main etc. that I had to look it up. If you're writing mostly classes to be run straight-up from the command line, you're doing it wrong.

Stormbringer5• 14 years ago

Actually, running the class straight from the command line can be a really cool way of doing ad-hoc unit testing.

You can have a main method that instatiates an instance of the class, populates it with whatever it needs (including mocks if you're into that sort of thing) and then exercises the various methods of the object.

It's like IoC but without all the bread and circuses.

NB: it's been about 8-10 years since I did anything like that.

Running from the command line is good for something that can run headless but you want to see immediate success/failure type messages.

The other main use I had for programs run from the command line was small 'one-off' file format conversion programs. Once you've done half a dozen of these it's relatively easy to just bang out the ~100 lines of code to do this (including proper exception handling).

Would it be faster to write it out in perl? Well, if the regex is sufficiently simple then yes, if it is moderately complex then you still use far fewer keystrokes, but getting it to the point that it is correct, that's easier in Java. (Assuming you optimise for readability, something perl... struggles ... with)

gruseom• 14 years ago

Actually, writing code that can be called directly from a prompt is the essence of using a REPL. The fact that Java, and OO programming generally, makes that so hard is a major weakness.

nessus429• 14 years ago

I write Java programs that are designed to be run on the command line all the time. Just what is it that I am supposedly doing wrong?

(That's not to say that most of the classes are to be run from the command line, but each CLI program has to have a class with such a method.)

Jach• 14 years ago

Admittedly I skimmed the blog post but I saw a complaint against the "Hello World", not how to print out a string. I agree the "System.out.print" thing is such a non-issue. If it really bothers you, make a class in your package that's a wrapper around it so you can call Utl.print() or U.o() or however short you want to make it. Meanwhile the rest of us will get back to programming. In the few years I've done a lot of Java development it's never bothered me enough to even make a vim shortcut for it.

However, the "Hello World" criticism does make sense to me in this sense. There are at least 18 separate facts you need to know to fully understand a Java "Hello World" program (including how to compile and run it). For [insert almost any other language (not C++)] there is considerably less. (Python is 4 facts.) If your goal is to teach someone who has never programmed before a new language, Java seems like a poor choice in that respect.

In any case, Clojure is where it's at right now man. It's pure awesome-sauce on its own and you get all of Java's goodies as a bonus.

tsotha7• 14 years ago

>Lispers like to pick on Java. It makes sense, because Common Lisp has everything that Java lacks.

But Java has a lot of things Common Lisp lacks, too. A GUI package. Network programming. Cryptography. Yes, you get modules for all those things. But having them in the core language means you know they're always available no matter where your code is running.

I like Lisp, even with its painful syntax and poorly named internals (Seriously. "cdr"? "endp"? Was there a Great Keystroke Shortage in the '60s?). But it doesn't have the ecosystem for actually producing a product to anywhere near the extent Java does. There's a reason Java is used so much more widely than Lisp.

In terms of syntax, I like what Rich Hickey did with Clojure. You still have all the Lisp functionality but it's a lot easier to read.

tikhonj• 14 years ago

There are reasons Java is used widely, just like there were reasons Cobol was used widely.

Now, car and cdr are just vestigially named, that is true. On the other hand, things like endp actually make sense--the p is a convention telling you that endp returns a boolean. It's short for predicate. I personally like Scheme's convention to name procedures like that end?, but endp also makes sense.

Also, the gui package in Java, for example, isn't really part of the language; it's part of the standard library. I don't see why that is a particularly big advantage, especially because you are not guaranteed to have it everywhere your code will run--for example, I don't think you have access to all of those libraries on Java ME.

Ease of reading is also a matter of habit. I actually find lisp code easier to read than most Java code, largely because the Java code tends to have a lot of random cruft (anonymous inner classes implementing a single method, for example).

hythloday• 14 years ago

> Seriously. "cdr"? "endp"? Was there a Great Keystroke Shortage in the '60s?

Well...yes? When jaw-dropping storage is a 1 MB hard disk, things like function names really do make a difference, especially when they're called so frequently. For the same reason, C89 identifiers are only 6 characters long (and hence the C naming convention of things like "strdup" rather than "duplicateString").

tsotha7• 14 years ago

Sure, because you can fit six characters in 32 bits. But still... those constraints are no longer with us, and there's a limited amount of historical cruft people learning a language today should have to deal with.

michaelochurch3• 14 years ago

Java has good libraries and some interesting concurrency primitives, and it's a major improvement over C++ (damning with faint praise) but the language is so verbose and adverse to intelligent programming techniques that I find it nearly unusable.

I have a theory about Java. In the '90s, it was not unheard-of for programmer productivity (individually and for the group) to be measured in LoC. Java's great advantage is that it's easy to be "productive" (100+ LoC/day) without accomplishing or thinking very much. An actually productive day can leave behind an eye-popping 750 LoC.

Reading that code later is another story.

One language that presently surprised was Scala. I expected to hate it based on the way it was presented to me, and found most online tutorials pretty weak, but the language is really cool. I definitely think it's "an acceptable ML", and the fact that it can leverage everything good about Java (including the libraries) is nice.

tsotha7• 14 years ago

>I have a theory about Java. In the '90s, it was not unheard-of for programmer productivity (individually and for the group) to be measured in LoC.

Nah, even by the mid '80s KLoC was discredited as a metric for programmers.

Java had a couple of big advantages over what had come before. For one thing, it promised, and mostly delivered, a true cross-platform ecosystem. It had a GC and the VM was written with hooks for IDE-based development. And it had a standard GUI package. C++ had none of that.

Java is verbose, but it's verbose because you have to be explicit with everything, which makes the code a lot easier to follow if you didn't write it. Poorly written Java isn't that much harder to follow than well written Java. You can't say the same about C++ or Lisp. Java is a tool for an organization where half the people are below average. Unless you're working for a very small startup or a flavor-of-the-month place like Google, that's probably going to be the story where you work.

EDIT: Oh, and it's been so long I forgot one of the major, major selling points. You could get free binaries. Almost everything else either cost money or had to be compiled (which was a royal pain in the ass in most cases).

spacemanaki2• 14 years ago

"(Seriously. "cdr"? "endp"? Was there a Great Keystroke Shortage in the '60s?)"

To be fair, CL has "first" and "rest" as well as "car" and "cdr". And as already pointed out, "endp" makes perfect sense if you want to establish a convention for predicates but don't want to allow symbols to contain special characters like ? marks.

(I know that CL allows symbols to contain ?s if you surround with with || but I don't think anyone seriously uses something like (defun |end?| (x) ... )

jwhite• 14 years ago

CL allows question marks in symbols without the || quoting.

Try it out at a repl.

Stormbringer5• 14 years ago

ITWARM (if this was a reddit meme)

Scumbag blogger:

Takes Tai-Chi for a couple of months, thinks he is qualified to talk about 'qi'.

Takes university course that touches on Java, dabbles in Lisp, thinks he is qualified to discuss 'failings' of Java

Begs the question: if Lisp is so amazing and Java is so bad, why is Lisp a failure in the marketplace?

----

Remember that even Lisp's biggest recent (as in, in the ~17 years since Java was released) success (Paul Graham selling his store-thing to Yahoo) was quietly re-written in Java a couple of years later.

If your answer to the success/failure question is that people who use Java are stupid-heads and people who use Lisp are wonderful geniuses, then may I suggest that you haven't solved the dilemma, you've just multiplied the entities by pushing it back a layer.

In any case, nobody cares about Java vs Lisp anyway. All the 'cool kids' in that space (e.g. functional programming on the JVM) are into stuff like Scala and Clojure. To ignore those makes the argument kind of pointless... it is like having an argument between a Dodgers fan and a Patriots fan. The Dodgers fan says the Dodgers are better because they hit more home runs than the Patriots, and the Patriots fan says the Patriots are better because they score more touchdowns.

It's just fundamentally stupid. Whereas if you compared Lisp and Scala, then at least you'd be talking about teams playing the same sport. Yes, it's still going to be as useful as watching a Patriots fan and a Dallas Cowboys fan argue about which is better, but at least the argument isn't based on fundamentallty stupid premises in that case.

almost_usual• 14 years ago

Your analogy doesn't make sense, Lisp and Java are both programming languages. Why not compare them? Also, learning Common Lisp can help immensely if you plan on doing any hardcore Clojure meta programming.

Stormbringer5• 14 years ago

Of course it makes sense, Baseball and Football are both sports, why not compare them? Because as different sports it isn't really relevant. Are you going to say that cricket is better than tennis because they can hit the ball further? It's a stupid argument. Just because two things belong in the same broad category doesn't mean that you can meaningfully compare them.

It is especially specious to bash Java for not being a functional language, because it doesn't try to do that. Java is heavily OO, not functional. So let's say that functional languages are 'better'. Let's just take that as a given. Why then would you single out Java and not mention any of the other languages that are also not functional? Why not bash Smalltalk, or Objective-C?

To single out Java simply underscores the irrelevance of the comparison.

Hence, rather than compare teams from two different sports, you should compare teams from the same sport. Likewise, if you want to make the claim that Common Lisp is the ultimate functional programming language, you should compare it to another functional programming language, not an OO language, or something like Prolog or COBOL.

nessus429• 14 years ago

As someone who has programmed professionally in Java, Scala, and Lisp (including Clojure), I might be qualified to assert that your sports analogy is off the mark. All of these programming languages can be effectively used to solve many of the same problems, though each language may excel at addressing certain kinds of problems better.

For me, programming in a dialect of Lisp is just more fun than programming in the other languages. Java is not fun at all, in comparison. And that's largely due to the fact that it can be difficult in Java to write reusable code. Consequently, you either have to repeat yourself a lot or tie yourself up in knots to figure out a way to not repeat yourself. Repeating oneself is tedious and boring.

On the other hand, static type checking can save you a lot of time debugging. But it can also slow you down. It's probably a net win overall for most problems, but for some problems, it is too restrictive. I find Scala to be a happy medium for most problems, but I often switch to Python for small programs, where the freedom from static typing can make development much easier and faster.

I think the problem with Lisp is that most people just don't "get it". I'm not sure why they don't, but perhaps it's a fact that I just have to accept. On the other hand, I firmly believe that the state of software engineering would be greatly improved if most programmers did get Lisp. I can't say the same thing about Java, however. In Java there isn't really much to get that you wouldn't get by learning any other OO programming language.

6ren6• 14 years ago

Came across this while researching Turing's proof that a turing machine can compute anything that is computable†. It's Church, comparing his and Turing's approaches:

> computability by a Turing machine ... has the advantage of making the identification with effectiveness in the ordinary (not explicitly defined) sense evident immediately. (1937a: 43.) http://plato.stanford.edu/entries/church-turing/

If we see imperative languages (e.g. Java) as descending from Turing machines, and functional languages (e.g. Lisp) as descending from Church's lambda-definability, the same observation seems to apply. It's not that Turing's approach is better, just easier to "get".

† "computable" meaning "can be computed" (not "computable with a turing machine"). Turing doesn't prove this formally - it's an intuitive appeal, and no exceptions have been found. See section 9, page 249 (page 20 of the pdf) https://docs.google.com/viewer?url=http://www.cs.virginia.ed...

pwpwp• 14 years ago

A lot of people are under the misapprehension that Lisp is a failure in the marketplace, when in fact many industrial applications use Lisp. Start with the following list: http://wiki.alu.org/Industry%20Application

Stormbringer5• 14 years ago

No, the better way to rebut this claim of ineffectiveness in the market would have been to say "which Lisp?"

The fact is that Lisp has spawned a great number of descendants. So to compare modern Java to some ancient version of Lisp from the 70s would be no more relevant than comparing modern Java to C++98.

But even that has it's problems for the Lisp fans, because if you aggregate all the work being done in various dialects of Lisp, it is still no more than a pimple on the ass of the donkey that is Java.

----

Your rebuttal fails specifically because the claim is not that work cannot be done in Lisp, but rather that for various reasons hardly any work is actually being done in Lisp. You're trying to disprove the strawman that no work is being in Lisp, congratulations your tilting at windmills was successful, but that was not the claim that was being made.

----

The question of why Lisp is not more popular is actually really interesting. Let me advance one theory - that Lisp programs devolve too easily into domain specific languages, and that impedes the transmission of ideas to other programmers. E.g. if I write some awesome Lisp code to solve problem X, it is hard for you to figure out what is going on until you understand what is going on - a chicken and egg type problem.

Whereas languages which remain mired in the foul stench of their own syntax and keywords are easier to understand because if I know the language (Java or COBOL or VB or C++ or whatever) then I am already halfway towards understanding the solution because the language it is expressed in is relatively static.

E.g. worse is better

rluhar2• 14 years ago

I understand that Java is verbose and does not have the same "instant" feedback loop that a language with a fully supported REPL has. But I do not agree with the assertion that Lisp would be a good substitute for Java as the core instruction language in a University course. If people are having trouble getting their head around Java, I think they would struggle with Lisp. Java, in it's simplest form can be written in a very imperative manner. Most people think sequentially, and if you are getting started with programming, writing a simple little program in Java, IMO, is easier than something like Lisp.

I am not saying Java is better, just that it has less cognitive overhead than Lisp.

I studied both Java and Haskell at University and found it much easier to get going with Java than with Haskell (I hacked lots of QBasic - I am getting on a bit - when I was a kid). Actually, I think a language like Ruby or Python would be much better suited for an undergraduate / dual major than Lisp or Java!

spacemanaki2• 14 years ago

The authors of How to Design Programs use Lisp (well, Racket/Scheme) and they are some of the most careful and thoughtful CS educators, who are appear to be thinking deeply about CS pedagogy (at least, this is the impression I get from reading some of their papers and some of HtDP). So I wouldn't be so quick to write off Lisp as an intro language over Java.

"I studied both Java and Haskell at University and found it much easier to get going with Java than with Haskell (I hacked lots of QBasic - I am getting on a bit - when I was a kid)."

I think Java is arguably closer to Basic than it is to Haskell, so this isn't really a very fair or representative data point. (I don't claim that non-programming undergrads taking CS 101 would be more successful if started with Haskell instead of Java, although I believe that's not unheard of).

rluhar2• 14 years ago

Thanks for your comment. I will take a look at the book you recommend.

To be honest, it has been a while since I was an undergraduate!

On a related note - how easy is it to transition from having first learnt how to program in Lisp (or a functional language) to programming in Java or C++? I have seen lots of blog posts about doing it the other way around (Java to Lisp). I would imagine that also requires a cognitive leap ..

Stormbringer5• 14 years ago

The claim has been made that it is easier to move from a formal education in maths to functional programs.

E.g. if you've been dealing with things like f(x)->g(x) in math class for a couple of years, then a functional language is a more natural fit.

This is why the iconic learning lisp examples are calculating numbers from something like the fibonacci sequence or factorials, rather than something that is actually useful in the real world. (Which is not to say that fibonacci numbers and factorials aren't useful, but rather that those problems are well and truly thoroughly solved already)

nessus429• 14 years ago

Lisp (Scheme) was the introductory language taught for CS and EE majors at MIT when I started as an undergraduate, and I found it to be the most intuitive language I had ever seen.

More recently MIT switched to Python.

Either one is a much better choice that Java. I would never have gone into CS if MIT had started us off on Java.

freshhawk• 14 years ago

Well if the author took the same care in determining that Lisp is better than Java that he did in "confirming the existence" of real life magical powers through Tai-Chi then why wouldn't I listen?

rbanffy• 14 years ago

"A year and a half ago, a dear friend of mine send me this link."

pg's "Beating the Averages" is not known widely enough. We must promote it more. We owe it to our friends who toil under inhumane conditions and work with sadistic technologies.

BTW, pg, I'm taking my "Hackers and Painters" to PyCon 2012. Will you have time to write a dedication? That is, if I get the book back from the colleague I lent it to. ;-)

wcdolphin• 14 years ago

It is too bad your example does not really convey anything interesting about the differences between clisp and Java.

The only thing I get from your essay is that Common Lisp has a REPL, which is sad because clisp is actually fun and interesting, and has a lot of VERY DIFFERENT things going for it.

Size of source code has never been a measure of the power of the language.

tsotha7• 14 years ago

I agree a "hello world" program is a good place to start learning but a terrible place to start comparing. To be fair, though, to really show the benefits of Lisp style programming you'd have to write something quite a bit longer. Long enough, in fact, you'd have trouble enticing people to read it.

arturnt• 14 years ago

The first thing that anyone who doesn't know Java complains about is running a main method, which no one in the Java world does 99% of the time. This is probably the first thing you have to do in a Hello World Java tutorial, but has nothing to do with Java.

There are some poor design choices in Java like no method overriding, mix of primitives and their boxed equivalents, lack of closures, or first class functions, confusing equals semantics, generics verbosity, etc. But main method is just moot.

Also it has nothing to do with superiority of Lisp over Java. Lisp has a different philosophy it's a functional language, while languages like Java, C, Ruby, Python etc are all imperative (see http://en.wikipedia.org/wiki/Functional_programming#Comparis...). I think a better article would be about the virtues of each style and when to use which.

nessus429• 14 years ago

One can program in Lisp in an imperative manner very easily and likewise one can program in Python in a functional manner very easily. The big difference between Lisp and Python (or Ruby) is not the functional nature of Lisp, but rather it's homoiconicity.

Re Java, I write CLI programs in Java all the time. It's fine for that, other than the annoying 1 second startup time.

Why I love Common Lisp and hate Java

Related Stories