Hacker News Reader

Comment by zak_mc_kracken | Hacker News Reader

Even for 2000, this paper is hilariously biased, starting with the observation that Lisp wins over Java in every single respect. If I order an evaluation paper and the paper comes back with 100% for choice B and 0% for choice A, I'm going to disregard it completely because the author is obviously too biased.

One of the strengths that Java has over Lisp is that it's statically typed. At the time, the direction of the industry wasn't too clear cut but this is clearly the trend today.

Another example of the bias is that the benchmarks compare development times (and Lisp wins, surprise surprise) but not maintenance time, which is admittedly harder to measure but a big liability that dynamically typed languages have.

View on HN

"One of the strengths that Java has over Lisp is that it's statically typed."

Common Lisp has optional static typing. Unlike Java, you have the choice, depending on what you're doing.

Here's a good discussion of static typing in Common Lisp:

http://www.lispforum.com/viewtopic.php?f=2&t=191

TL;DR is that many CL implementations will check types at compile time, but for appropriate speed and safety settings, they will also generate code that checks types at runtime, too.

> Common Lisp has optional static typing

That depends on what you mean. CL declarations are promises to the compiler. They permit the compiler to make optimizations but does not require it to signal compile-time errors. Specific implementations may give you compile-time errors, but in general you can't count on it the way you can in Java.

Then you are biased towards papers which don't offer a clear choice. Sorry, couldn't resist ;)

> One of the strengths that Java has over Lisp is that it's statically typed.

With the caveat that Java's type system can be subverted and isn't expressive enough to catch any more than the most trivial kinds of errors a type system can catch.

That's a straw man, we're comparing Java to Lisp, not to another statically typed language.

Because Java is statically typed, it catches a lot more errors at compile time than Lisp can.

Lisp is optionally statically-typed. I am not aware of any type error Java can catch at compile time which Lisp cannot catch at compile time.

Now, whether or not a particular implementation does catch it is an entirely different affair.

Most type systems (including Haskell's) can be subverted. Java does catch many common errors, typically of the form "I refaxtored, now this function takes 4 args instead of 3" or "this function returns an X now".

The latter sort are, in my experience, the most common form of type error and catching g them is awesome.

"Expressive" tends towards "complex". I would argue that Java's type system is pretty simple which is a good thing - a pragmatic choice. You sound like you're making "perfect" the enemy of "good"

Reply on news.ycombinator.com