
Lisp Wins (Steve Yegge article) - smanek
http://steve.yegge.googlepages.com/lisp-wins
======
elai
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.

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

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

------
pmjordan
_"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.

~~~
brlewis
In 2004 I had already been using Kawa Scheme on the JVM in my day job for 4
years. That's also the year I began OurDoings using the same technology.

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

~~~
jimbokun
Are you also familiar with Clojure? How would you compare the two?

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

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

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

rofl...

~~~
smanek
Interestingly, the author didn't show that program in lisp ... which do you
think is better style:

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

~~~
ken
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)))?

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

