

Ask HN: Is clojure (lisp in JVM) next big thing? - btw0

There seems to be a lot of people even some intelligent ones who are lately talking about and exploring clojure, a new lisp dialect run in JVM. It looks really promising, but a lot of people especially lisp programmers have an inherent hatred in java. How is that? what do you think about this ``lisp in JVM''? Is the clojure the future of lisp?
======
drcode
The reason Clojure is successful right now IMHO is because:

    
    
        1. It isn't afraid to revisit the basic design tenets of Common Lisp and Scheme
        2. It has reasonably useful libraries (both through the JVM and written in native Clojure)
    

No other Lisp dialect has done this recently. My point is that its success
doesn't have much to do, from what I can tell, with the actual design of the
language. Clojure does fix annoyances in CL and Scheme (low hanging fruit) but
I personally still prefer other modern dialects, like arc, in terms of basic
language design.

The reason arc is crashing and burning right now is that it doesn't address #2
at all. Plus, arc is suffering from an absentee benevolent dictator.

~~~
pg
Powerful libraries are a cheap way to make a new language the language du
jour. (Think Rails.) They're not the critical ingredient if you're trying to
make something to last; they may even hurt.

~~~
mixmax
Yes, but without powerful libraries a language isn't much good for real world
use. And if nobody uses the language it won't have a community and feedback.
Without a community people will move on, and it will end up as a pet project.

~~~
pg
There are two senses of powerful: breadth and depth. To make a language
massively popular you need breadth. But for a language to have a user
community all you need is depth, which is why I released news.arc with Arc.

------
twopoint718
There is a video (<http://clojure.blip.tv/>) by the creator of Clojure which
argues (quite convincingly) that it is really Java, the language, that some
people may have problems with and that Java, the runtime environment, (JVM) is
a great platform in which to target your code.

Lots of work is being done in areas such as JIT and adaptive optimization in
the runtime environment. By targeting the JVM you get to take advantage of all
that work put into optimization and thousands of libraries; it gets you a lot
of leverage fast.

------
gtani
arguing about clojure vs. scala is the next big religious war

<http://www.cio.com/article/print/454520>

[http://almaer.com/blog/the-next-big-language-theory-
practice...](http://almaer.com/blog/the-next-big-language-theory-practice-and-
the-killer-app)

------
ivanstojic
I find that after a year of Common Lisp, I don't really care about Clojure. On
the other hand, through the JVM and the Java API, it offers for free some of
the things which were never available as a CL standard feature.

However, CL is a language specification, while Java is for better or worse
much more than that.

------
markessien
Lisp will never be popular. We are humans and our brains are wired for a
certain type of thinking. Lisp breaks this model, and so it's difficult for
people to pick it up.

The trend has always been to easier and easier languages - I don't remember
any case where a more complex language, no matter how useful, has become the
next big thing.

The only thing that can make lisp popular is a framework or API based off it.
Something that offers something new or something easier.

~~~
ajross
So how does that trend explain C++, or Java, or C#, all of which are clearly
evolving in the direction of increased complexity. Likewise Python today is a
vastly more complicated environment than the language I learned 8 years ago.
And Ruby is quirkier still, taking most of perl's weird syntax and adding an
object model from smalltalk and a statement-based execution metaphor that
comes straight out of BASIC -- certainly not a "simple" language.

C is a simple language. Scheme is a simple language. Everything else is
growing more complicated by the day.

~~~
markessien
A language will always grow in complexity. But it does not become more popular
because it grows in complexity.

My point was that the trend in popularity is towards less complex languages -
i.e, languages that abstract away difficulty. In that respect, C++ is less
complex than C.

~~~
neilc
_less complex languages - i.e, languages that abstract away difficulty_

That is a very anomalous definition of complexity. In truth, a language that
is more complex may or may not be more abstract. For example, Prolog operates
at a very high level of abstraction, and it is far less complex than a
language like C++.

 _C++ is less complex than C_

C++ allows programs to be written at a higher level of abstraction than C, but
it is not less complex than C by any reasonable definition of "complexity". In
fact, it is the very existence of the C++ tools for abstraction (classes,
templates, virtual functions, MI) that cause much of C++'s language
complexity. Perhaps you are conflating the complexity of the _language_ with
the complexity of a typical program written in that language?

------
schtog
It is possible to write very dense and abstract functional code that is hard
to understand but some Lisp-code is so readable you wonder if it is actually
code!

That said I don't see Lisp becoming big. Scala probably has a better chance.

Scalalooks great on paper and is better than JAVA in my opinion. However in
practice it still feels very heavy and kind of JAVA-ish. Not for me but
perhaps a natural step for a lot of JAVA-developers.

------
michaelneale
Anyone played much with compjure? I loved the ideas in it - last I tried
however I wasn't able to make changes and refresh - I had to restart the app
to see changes. Interestingly (and nicely) it "compiled" the changes up front,
telling me of any errors. That part was nice but having a F5 refresh/change
cycle for web apps I think is expected now.

------
Dilpil
Good luck teaching the unwashed masses lisp.

~~~
PieSquared
A friend of mine was being taught Java in an introductory programming course
(although he already knew some BASIC). He was having a lot of trouble, so I
introduced him to Lisp... After touring through some of the more basic
features (no macro-writing or call/cc), he responded with, "Whoa... This is so
much simpler than Java, it makes so much more sense."

My take on that was that the only reason people find Java easier is because
it's more similar to other curly-brace languages, the ones they already know.
If you take a newcomer to programming, Lisp just _may_ actually be _simpler_.
So the unwashed masses still have some hope.

