I don't accept that his particular verbose version of doing things in java is acceptable. Just because dynamic language x does x things hidden behind a bunch of code means that you have to emulate the exact same things in another language to achieve the same result.
It's bad smalltalk to emulate C while your programming for it, and similarly it's bad C to emulate smalltalk with it. It's like I would take his original java version and made it into perl, insisting that the perl script HAS to be in a class definition, and HAS to be in a main method, I MUST define the resultset in a static class list, and output with separate methods. Saying that perl couldn't reproduce my 'reusable object' java functionality with doing that is just pedantic.
He should of just extracted a real example where it's impossible to do something in a short amount of code due to the lack of a specific feature, or being chained to java's static typing. Like converting a JDBC ResultSet to an int[]. (5 lines of code, 15 if you don't compress the curly brackets)
A real life implementation of his example:
public class Out { public static void main(String args[]){ for (int i = 0; i < 6; i++) { System.out.print(''+i*i+' ');} System.out.println();}
Also just because a language is succinct, doesn't mean it's productive. Just look at SML. It's many, many restrictions act as a straitjacket to do simple things, yet also keeps things succinct. It's would be better to say that because of intentional restrictions x (static typing) or lack of feature y (first class functions), it makes it that doing some simple thing z is forced to used workaround a. Because language b has this feature set, this leads to general bureaucratic overload.
Java isn't bureaucratic just because of the language alone, Sun & apache contributes a lot of this itself in how they've programmed their standard libraries and their love affair with XML.
Can you give a few examples of SML's "many, many restrictions"? The only things I can think of that fit that description are the value restriction and lack of first-class polymorphism, but neither of these should have a serious effect on productivity.
When I was given assignments for SML, I was constantly running into x or y restriction whenever I tried something. Maybe my prof knew how to setup his assignment for maximum frustration using SML, and normal usage is not so bad (after you gain some skill in it), I don't know. But consensus from my class & some people on the net is that it shouldn't take hours to get a 10 line program working. Principle of least surprise is something SML does not follow. Also there's a lack of a support network & decent documentation for it compared to more popular languages out there. I'd rather use lisp than the traumatic experience SML was. At least the syntax isn't much to learn.
"Note: although I came to the conclusion in this article that Lisp beats Java hands-down as a language, more research has got me thinking that Java beats Lisp hands-down as a platform..."
These days (article is from 2004) we have the luxury of being able to use expressive languages within a large library ecosystem by using implementations of them in the giant platforms that have been built by Sun and Microsoft. Personally, I'm using Clojure, a Lisp dialect on the JVM, for all my explorative programming. Yegge himself seems to be working with Rhino (JavaScript on the JVM) these days.
I'm not familiar with Clojure, but as I understand it's a new language. Kawa is R5RS Scheme except it can't capture continuations. Kawa has the advantage of being a fast compiler. SISC is an interpreter, but it is more completely standards-compliant Scheme.
That 0.5 million line java game of his must be really something. I saw some screenshots and it reminded me of things I played on Windows 3.1. Dollars to donuts he's going some wtf-worthy stuff in there.
ED: Oh, yeah, reading through the article, I see it must be true. His "print the squares" example is pretty bad. If I did it (using some home[green]spun libraries) it would look like this, more or less:
List squares=Util.makeList(Util.makeList(1,2,3,4,5),Util.class,"square");
System.out.println(squares);
(Reflection is being performed, with "square" being a static method from Util.class) Really, I would need a Util.makeRange(1,5) function to get closer to perl.
this is not true is it?
there must be a way to make this shorter, otherways that is completely ridiculous.
""""
The equivalent code in Java, as reasonably compressed as I could make it, is:
import java.util.;
public class Fugger {
public static void main ( String[] args ) {
List numbers = new ArrayList();
for ( int i = 0; i < 5; i++ ) {
numbers.add ( new Integer(i) );
}
List squares = new ArrayList();
Iterator it = numbers.iterator();
while ( it.hasNext() ) {
int i = ((Integer)it.next()).intValue();
squares.add ( new Integer(i * i) );
}
Iterator i2 = squares.iterator();
while ( i2.hasNext() ) {
int i = ((Integer)i2.next()).intValue();
System.out.print ( i );
if ( i2.hasNext() ) {
System.out.print ( " " );
}
}
System.out.println();
}
}
""""
and his example in python:
' '.join([`x x` for x in range(1, 6)])
If you just want to print the same output, you can be ever so slightly shorter than his Perl/Python:
(dotimes (i 5) (print (expt (1+ i) 2)))
This doesn't follow his semantic steps, so it's kind of cheating, though in a real program I have a bunch of utility functions to help me out so it's about the same:
(join " " (mapcar #'sq (range 1 5)))
I think the point is not that Lisp is shorter for any given toy problem, but that Lisp allows you to build such abstractions. Even if you had join() and range() and sq() in Java, what's Java for (f x (mapcar #'g (h y z)))?
Lisp is as good as you are good at programming language design. Otherwise Lisp will result in an incomprehensible code.
The fact is there are not so many good language designers.
It's bad smalltalk to emulate C while your programming for it, and similarly it's bad C to emulate smalltalk with it. It's like I would take his original java version and made it into perl, insisting that the perl script HAS to be in a class definition, and HAS to be in a main method, I MUST define the resultset in a static class list, and output with separate methods. Saying that perl couldn't reproduce my 'reusable object' java functionality with doing that is just pedantic.
He should of just extracted a real example where it's impossible to do something in a short amount of code due to the lack of a specific feature, or being chained to java's static typing. Like converting a JDBC ResultSet to an int[]. (5 lines of code, 15 if you don't compress the curly brackets)
A real life implementation of his example: public class Out { public static void main(String args[]){ for (int i = 0; i < 6; i++) { System.out.print(''+i*i+' ');} System.out.println();}
Also just because a language is succinct, doesn't mean it's productive. Just look at SML. It's many, many restrictions act as a straitjacket to do simple things, yet also keeps things succinct. It's would be better to say that because of intentional restrictions x (static typing) or lack of feature y (first class functions), it makes it that doing some simple thing z is forced to used workaround a. Because language b has this feature set, this leads to general bureaucratic overload.
Java isn't bureaucratic just because of the language alone, Sun & apache contributes a lot of this itself in how they've programmed their standard libraries and their love affair with XML.