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.

You just gave me an idea for an excellent April's Fools prank.

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.

http://ourdoings.com/2004-08-24

http://sisc-scheme.org/

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);

"""" 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)])

rofl...

(mapc #'(lambda (x) (print (expt x 2))) (list 1 2 3 4 5))

or

(loop for i from 1 upto 5 do (print (expt i 2)))

interestingly, they are both longer than python/perl ...

Not to turn this into a game of Golf, but is there any shorter way?

(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)))?

  (define nums '(1 2 3 4 5))
  (write (map * nums nums))

  user=> (map #(* % %) (range 1 6))
  (1 4 9 16 25)
  user=>

(pr (map [* _ _] (range 1 5)))