Clojure is *NOT* an acceptable Lisp

Clojure revolts me.

It is the most explicit to date abandonment of the age-old Lispers' Dream, which was "Lisp All The Way Down." Clojure is the antithesis of the Lisp Machine. Rather than a crystalline pyramid of comprehensible mutually-interlocking concepts, behind every Clojure primitive there lurks Black Magic. The Clojure user who is missing some routine or other will run crying to Java for help, rather than implementing the feature himself correctly - that is, as a natural part of the entire language, built on the same concepts. Clojure pisses on everything I've ever loved about Lisp. It rejects even what little consistency and intellectual rigor there is to be found in an abomination like Common Lisp.

Clojure is the False Lisp, which Reeketh of the Cube Farm.

I don't care if everybody really is more productive in Clojure than in Common Lisp. The latter is not my standard of comparison (Symbolics Genera, the state of the art, is. Or, if you want something that is distinctly inferior but is currently available on the market: Mathematica.) Clojure is the gutted corpse of a dream.

I am tired of this abomination being hailed as the future of Lisp. Users of real Lisps, such as myself, will keep hoping, dreaming, and working on systems which do not betray the original virtues of the language.

Check em

There are two notions of Lisp:
1. Lisp as a tool for solving the meta-programming problem and explore computation.
2. Lisp as an ideology, very similar to communist empire ideology.

Check em

For the first time in /prog/ history, I agree with a >>1.

Pasta but I agree. The problem is the convenience of Java libraries is too hard to ignore for me. Clojure is like C++, it can be useful if you confine yourself to a subset. Clojure is still better than 90% of other languages out there.

>>6
So which Lisp should I choose? Which Lisp is right for me?

>>7
Arc

>>7
Brainfuck is an acceptable Lisp.

There already is an acceptable Lisp: JavaScript, a dialect of Common Lisp.

>>3
Communism is good.

>>6
What convenience of the Java libraries? They are designed in a way that runs completely counter to any Lisp.

>>11
Define good.

>>11
if that's a Negativland reference, I understood it. also nice dubs

Clojure is a Lisp

Check em

>>15
Clojure is NOT a LISP.

>>17
It is, it's just not an acceptable one.

>>18
By whom? Is list-acceptance a subjective thing?

Make LISP Great Again.

Make LISP Clojure Again.

The only Lisp that was ever acceptable is Perl

>>6

no type system
better than 90% of other languages out there

I think not.

>>23
Who are you quoting?

>>12
Time is a resource. If you want to squander one of our most precious resources re-writing every single library already available in the Java eco-system for the sake of purity then good luck to you.

Squandered dubs

What programming language is this?

>>27
Javascript is the only acceptable Lisp.

Javalisp

Check em

_,-""""-..__ _,-""""-..__ _,-""""-..__ _,-""""-..__ _,-""""-..__
|`,-'_. ` ` `` `--'""". |`,-'_. ` ` `` `--'""". |`,-'_. ` ` `` `--'""". |`,-'_. ` ` `` `--'""". |`,-'_. ` ` `` `--'""".
; ,' | `` ` ` ` ``` `. ; ,' | `` ` ` ` ``` `. ; ,' | `` ` ` ` ``` `. ; ,' | `` ` ` ` ``` `. ; ,' | `` ` ` ` ``` `.
,-' ..-' ` ` `` ` `` ` ` |==. ,-' ..-' ` ` `` ` `` ` ` |==. ,-' ..-' ` ` `` ` `` ` ` |==. ,-' ..-' ` ` `` ` `` ` ` |==. ,-' ..-' ` ` `` ` `` ` ` |==.
,' ^ ` ` `` ` ` `. ; \ ,' ^ ` ` `` ` ` `. ; \ ,' ^ ` ` `` ` ` `. ; \ ,' ^ ` ` `` ` ` `. ; \ ,' ^ ` ` `` ` ` `. ; \
`}_,-^- _ . ` \ ` ` __ ` ; # `}_,-^- _ . ` \ ` ` __ ` ; # `}_,-^- _ . ` \ ` ` __ ` ; # `}_,-^- _ . ` \ ` ` __ ` ; # `}_,-^- _ . ` \ ` ` __ ` ; #
`"---"' `-`. ` \---""`.`. `; `"---"' `-`. ` \---""`.`. `; `"---"' `-`. ` \---""`.`. `; `"---"' `-`. ` \---""`.`. `; `"---"' `-`. ` \---""`.`. `;
\\` ; ; `. `, \\` ; ; `. `, \\` ; ; `. `, \\` ; ; `. `, \\` ; ; `. `,
||`; / / | | ||`; / / | | ||`; / / | | ||`; / / | | ||`; / / | |
//_;` ,_;' ,_;" //_;` ,_;' ,_;" //_;` ,_;' ,_;" //_;` ,_;' ,_;" //_;` ,_;' ,_;"

Pretty much everything I've built over the last decade has run on the JVM so languages that don't integrate with that stack are out of the question for me. The interop allows me to mix languages and to slowly migrate codebases from one language to another, where appropriate.

I like Lisps but their previous inability to interop closely with other work I've been doing has prevented me from adopting them (similarly Haskell is very appealing but without full interop with Java, it's not useful to me). Clojure finally provides that interop in a Lisp, and does so in a very interesting and high performance way.

Perhaps most importantly, Clojure is based on the idea of immutable data, making concurrent programming much easier / safer.

check em dubs

>>32
You do know that every major Lisp has native interop/FFI as well, right? And it's probably easier to use than Java's. Your argument is invalid, and your head is firmly stuck in the sand.

>>32

high performance

that's very relative. I've been generating large primes for muh crypto in various bignum C libs (e.g. Pari + GMP) and in Clojure and Clojure was slow as balls in comparison. JVM is better than it used to be but it's still not as fast as native code.

>>35
Does “high performance" actually mean “only the fastest around”? I don't subscribe to this definition. I can consider an implementations of something to be “high performance” even if they are slower than “the fastest”.

>>33
Dubs checker: v0.14 Input:33 Result:OK
____________
< Well done! >
------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||

>>36
this depends on your needs. sometimes you need to optimize, sometimes you don't. when I was doing my project, I considered this difference significant and went with the low-level solution

>>35
Clojure is much slower than Java depending on how you write your program. If you're using lazy sequences extensively, then yeah, it will be slow as balls, as lazy sequences in Clojure weren't designed for performance.