Comment by Stormbringer | Hacker News Reader

Comment by Stormbringer | Hacker News Reader

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.

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.

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...

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.

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.

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?

There's nothing specious in an argument that isn't as general as it might be. If I soundly argue that red space ships are faster than blue cars, it's still a sound argument, even if I might have also successfully argued that all space ships are faster than all cars.

In any case, Java is often singled out because it is egregiously bad in quite a few ways, but arguments that claim that Lisp excels in certain ways compared to other languages, would typically apply against Smalltalk and Objective-C. (Though Smalltalk is dynamically typed, so that might be a putative virtue that Java doesn't have.)

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

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

Reply on news.ycombinator.com