

Thumbs Down for Clojure - yangyang
http://www.loper-os.org/?p=42

======
menloparkbum
This guy is insane, everything he writes is a lame rant about how life sucks
since the demise of Symbolics.

However, I will have to say that I was initially excited about Clojure and
each day become more disappointed because it really does carry with it all the
baggage of Java. I had vowed to avoid CLASSPATH hell the rest of my
programming days and Clojure often makes me feel like I'm lying to myself.

~~~
yummyfajitas
I'm also disappointed by Python. It doesn't make using windows any more
tolerable than before.

But maybe I'm being unfair, expecting my programming language to solve the
problems of my operating system.

~~~
menloparkbum
Yeah, you're being unfair, especially if you've used both Python and Java and
consider them equivalent in terms of laborious configuration details. When I
say CLASSPATH hell I mean the whole configuration mess that is maintaining a
java environment. If you have any tips on making this not suck in Clojure it
would be great to hear them, otherwise I am switching back to Python.

------
nod
"I don’t care if everybody really _is_ more productive in Clojure than in
Common Lisp."

That's where the author lost me. I'm willing to entertain the argument that a
hybridization of Java and Lisp is not nearly as effective as one would hope -
but the universal ultimate goal is MAKING THINGS.

~~~
jimbokun
He inadvertently revealed the secret mantra of comp.lang.lisp. Purity
supersedes productivity, practicality, and pragmatism.

~~~
Semiapies
This is a real problem with a lot of small communities that don't understand
why the awesome thing they like hasn't taken over the world.

~~~
dasil003
Well hopefully they realize it won't take over the world and they are okay
with that.

The minute you start doing actual work for paying clients is the minute that
compromises sneak in. Certainly the last thing these people would want is for
the LISP community to become like the PHP community where the few nuggets of
good code are drowned out by flood of sewage. Maybe someone thinks you
couldn't write code that bad in a pure LISP, but believe me you would see some
pretty horrendous crap if LISP had 10% marketshare of, let's say, web
programming.

~~~
Scriptor
Frankly, this fear just sounds too much like "Oh no, I'd hate to see anything
tinge my precious baby!"

What's wrong with there being poorly written code in your favorite language?
Unless these Lispers also do web development, they likely won't come in
contact with the hypothetical bad Lisp-on-web code. So why should they care?
Also, how is the good code drowned out? Assuming that the screening process
for a job picks out good PHP developers, it isn't that hard for one to find
good PHP code in the form of frameworks and libraries.

~~~
dasil003
Well sure, to normal people yes. But to understand the mentality, just
consider for a second that the OA is foaming at the mouth of a language that
is merely inspired by LISP.

wrt the PHP thing, well, I cut my teeth on PHP, and frankly I didn't learn
much by reading code I found early on. After doing it for a couple years (and
completing an MIT-based CS degree) I started to discover the flaws for myself
and I was eventually well-trained enough to be able to find the good code. If
you know what to look for it's easy. However what's popular in PHP world (ie.
what you find on Google) is not necessarily good. Compared to Ruby or Python,
or hell, even Perl, it's just way harder to find good PHP code to learn from
for a beginner.

------
arohner
Fine, don't use Clojure. Myself, I'll get stuff done, and not whine about the
fact that my laptop's BIOS is not written in lisp.

~~~
michaelneale
It is interesting, how if someone doesn't like something they seem to see it
as their mission to make sure no one else uses it? (or it appears that way,
what I think it really means is self promotion, and its easier to tear down
then build up when building your profile in public).

~~~
zcrar70
_they seem to see it as their mission to make sure no one else uses it_

I don't think they necessarily do - they're just saying what they think, but
then other people read it and get annoyed (justifiably.)

That's the thing with blogs, the entire world can hear your opinion, and
sometimes it would have been better if they didn't.

~~~
michaelneale
hahahah - yes, so true.

Actually in this article, when I re-read it, I think it is written in a sort
of ironic/fun tone.

Although I love clojure, I understand the disappointment in not being "lisp
all the way down" - there is something satisfying about the purity of that
approach, if it is practical. Maybe one day...

------
radu_floricica
If he got anything right, it's the "good enough" thing. There's a sense of
reality in clojure, of compromises and of practicality.

There's also a sense of abandonment of some of lisp's dreams. There is
definitely a break from the way lisp was, and it's clearly deliberate (defn vs
defun for example). But at the same time, this _is_ a lisp for the XXI
century. Old dreams needed to die for progress' sake.

I strongly disagree though about the importance of understanding everything
all the way down. It's not a bad thing per se, but pales in comparison to
being able to work easily with what others have made. Another compromise, and
one well chosen in my opinion. The vastness of java space compensates more
then a hundred times the lack of transparency.

~~~
marcusbooster
So at what point of abandoning some of the fundamental ideas do you have
something else entirely?

I hate all this "dream" talk, it's not a dream it's been implemented. If you
don't want to use it fine, but don't pretend to be taking all the good and
leaving the bad. Imho having to deal with Java classes is just substituting
one bad for another (or worse).

~~~
Semiapies
Well, you can either have just "perfect" implementations of an obscure
language very few people are coding in, or you can also have an implementation
of a similar language that is imperfect while actually gaining mindshare for
both languages.

Who's more likely to bother looking at some other version of lisp, someone
whose experience is C++, Perl, and Java, or someone who's used Clojure?

This isn't the perfect as the enemy of the good so much as the perfect not
willing to let the good _be its friend_.

------
jsmcgd
The author embodies Lisp's self-defeating idealism. Hurray for pragmatism,
hurray for Clojure.

~~~
utx00
this comment reminded me of this: [http://philip.greenspun.com/bboard/q-and-a-
fetch-msg?msg_id=...](http://philip.greenspun.com/bboard/q-and-a-fetch-
msg?msg_id=0006XQ)

------
100k
Wow, that was the most fappish programming rant I've ever read.

"I don't care if people are more productive! It's not the pure genius of
Symbolics LISP!" WTF?

~~~
jrockway
But it's not the pure genius of Symbolics LISP. The genius of the Lisp
machines is in their extensibility and consistency all the way down. (This has
nothing to do with Lisp, BTW, but rather with the design of the system and
runtime. The syntax is nice, but largely irrelevant.)

The closest I've ever come to day to day use of a Lisp machine is Emacs. It is
wonderfully different from "worse is better" systems like UNIX and
Clojure/Java. With a few keystrokes, I can use my tool to change my tool...
instantly. Everything is as deeply aware of everything else (if it needs to
be). The result is an extremely comfortable environment where anything seems
possible. (I recently switched from bash + ansi-term to eshell. UNIX is much
nicer when you can see it through a lisp-colored shell.)

Anyway, I guess this isn't really related to the article... but if your view
of programming consists of strings being passed along pipelines and huge,
monolithic cathedrals that claim to be "IDEs", you are not seeing the whole
picture.

~~~
100k
Symbolics LISP machines were pretty awesome, you're right.

People are writing real software, right now, in Clojure. In my book, that's a
win for LISP and beats wanking about what could have been any day.

------
herdrick
Hilarious. But this sentence is great:

 _My standard of comparison for any technology will always be everything
previously achieved by mankind, rather than what is available on the market
today._

Exactly the right attitude, except here it seems to be harming this guy's
life.

------
strlen
I find it strange that the original author only suggested proprietary
alternatives (Lisp Machines, Mathematica), noting that Common Lisp itself not
immune from these same criticisms. What's also interesting is this:

Java itself, at its helm had/has people such as Guy Steele who _knew_ that
since people would be unwilling to adopt languages such as Common Lisp or
Smalltalk, best they could hope would be to "sneak" many of the features these
languages originated (reflection, generic programming, garbage collection,
DSLs, object orientation) to the people who would benefit the most from them.
Java was a great covert vehicle for this "feature-sneaking", with its C-like
syntax and enterprise buzzwords.

Now with Scala and Clojure (as well as Jython and JRuby), it seems like this
an even _more_ ambitious to sneak powerful programming tools and paradigms
(dynamically typed languages, functional languages) to the professional
programmer community, this time by saying "this is just a jar/war file".

If the goal is adoption of proper Lisp-from-ground up architecture, then sure
this "sneaky" approach isn't going to get anyone there. But what if the goal
is better code and more productive coders?

~~~
lispm
How much impact had Guy Steele on the design of Java? My guess was always that
Java was mostly designed when he arrived and he was hired for his experience
in standards and his writing capabilities. Given that Mr. Steele co-wrote a
book on C, worked on the standard for High Performance Fortran, the CL
standard, and other things.

------
dkarl
_The Clojure user who is missing some routine or other will run crying to Java
for help, rather than implementing the feature himself correctly.... Clojure
pisses on everything I’ve ever loved about Lisp._

In other words, Clojure bypasses a major part of what everyone hated about
Scheme and Common Lisp, the unfortunate combination of inclination, culture,
and fragmentation that prevented the natural development of a library
ecosystem like the ones enjoyed by Perl and Java. Furthermore, this guy's
comments reveal that for some Lisp hackers, at least, the bias against
libraries was real and not accidental. To guys like this, the desire to just
install a library and get the job done stands right beside "too many
parentheses" as a stupid noob concern that a real Lisper will grow out of.
Let's hope Clojure represents a symbolic moving-on from this self-defeating
and chauvinistic attitude.

~~~
lispm
not really. The Symbolics Lisp Machine came with a huge library of thousands
of class and 30000+ functions.

Additionally it had compilers for Fortran, C, Pascal and others. It could
compile things like TeX and X11 on the Lisp Machine.

He just does not want to build on the JVM. I can understand that. The JVM is
optimized for Java and nothing else. SUN has not done much to support other
languages (functional, dynamic, ...) on top of the JVM (Microsoft does that
with its .net infrastructure, though). Using the JVM for Lisp is fine, because
it is there. But it is ugly, since it is alien for Lisp. More alien than x86
is for Lisp.

~~~
dkarl
His complaint is that the JVM libraries are not coded in Lisp: _opaque
routines having no underlying Lispiness_. He would rather have no libraries at
all, so every programmer needing library functionality has to "implement the
feature himself correctly," where "correctly" means "in Lisp." His aesthetic
sense has run amok and is out to destroy everything that isn't a "crystalline
pyramid," regardless of how useful it is.

 _Additionally it had compilers for Fortran, C, Pascal and others._

Until this wacko logs in and deletes them, or replaces them with trojans to
teach you a lesson about intellectual rigor ;-)

 _The JVM is optimized for Java and nothing else._

That's true, but x86 is optimized for C and nothing else, so how can you do
any better (in real life?) At least the JVM has potential. Sun has realized
that dynamic language performance is important, and they're busy improving
support for languages like Jython and JRuby. Lisps will benefit from that
work.

------
gchpaco
I retain a great deal of affection for environments like Squeak, like Emacs,
where you can stand as high up or as low down as you like in the system. Emacs
has primitives written in C, of course, and Squeak doesn't cooperate real well
with the rest of the world, but it's still a very powerful idea.

It makes me a little sad that one cannot learn Java programming by e.g.
loading up Eclipse and saying "what's the code for this thing?", in the way
that Squeak, Emacs, many Forths, R, and yes Symbolics Lisp permitted.

------
gruseom
Could there be a more self-defeating way to make this argument? This is the
kind of thing that makes people write psychoanalytical essays about Lisp
programmers.

------
buugs
He seems to have missed the point of being built on java.

------
scott_s
I have never heard any Clojure proponent encourage anyone to implement
functionality at the Java level. I don't program in Clojure or Java, but it's
obvious to me the idea is that the JVM is just the "operating system" for
Clojure.

~~~
lispm
So you would not write hybrid Java and Clojure programs? You would not reuse
and extend Java classes? Strange. I thought Rich went to the JVM because the
eco system is so rich ;-) and not just because it happens to have a code
execution environment and a garbage collection implementation.

~~~
pwncat
When you're writing Clojure code, you generally are supposed to prefer Clojure
features and idioms. Functions like proxy and gen-and-save-class exist because
sometimes you have to create classes to use other Java APIs.

------
vdm
If Clojure is getting reactions like this, it must be doing something right.

------
ngvrnd
The author does indeed describe what is "wrong", but perhaps not explicitly.

------
jodrellblank
_Symbolics Genera [..] can never be un-created_

Can it be recreated?

~~~
Semiapies
In theory, I suppose.

Of course, I find myself wondering - in what world is such a thing most likely
to happen? In a world where lisp sits in obscurity, or one where some
"revolting" lisp actually gets a significant developer base? :)

------
pwncat
Two words: stone soup.

The JVM is just a starting point, and a very good one for that.

~~~
lispm
just not for a Lisp dialect. The mismatch is known and widely documented.

