Why is Clojure over other Lisps JVMs: kava, armed bear or SISC?

Question

The JVM already had three Lisp before Clojure arrived on the scene: Kawa , Armed Bear and SISC .

What is the difference between Clojure , which remained these Lisps?

Answer 1

Kawa, ABCL and SISC are re-implementations of existing languages ​​that are quite long in the tooth. They are excellent if for some reason you want to use the standard schema or the standard Common Lisp in the JVM.

Clojure is a new language. It does not fill in the gap. This adds completely new features. This contributes to a purely functional approach — circuitry and CL are both multiparadigm. Clojure is heavily dependent on the design of various FP languages ​​(ML, Haskell).

And yes, you could add concurrency support for other Lisps, but that is completely meaningless. Clojure was designed from the very beginning as a parallel language. So much so that writing parallel programs is trivial in Clojure - not rocket science, as in non-functional languages ​​(scheme, CL is not excluded). Take a look at this way:

People say that C allows you to write fast programs by default.

Well, Clojure allows you to write parallel programs by default.

Answer 2

• "Clojure is non-backward compatible Lisp" (from the Clojure website). This is a new beginning. It is progressing. Use ideas that make Lisp / Scheme powerful, but rethink them around the Java platform.

• Clojure will always be the last Clojure. With any other language ported to the JVM, the JVM version can always play catch-up. If you don’t need the Java platform, why use SISC on another schema? If so, why not use one Lisp (Clojure) that was specifically designed for it?

• Designed with concurrency in mind.

Answer 3

The simplest answer I can come up with is that Clojure is not generic - Lisp. Clojure is not limited to the history of other Lisps. This is a new language created for the JVM.

Answer 4

I simply did not know about those that were of serious benefit to Clojure (that people were making enough noise that I recognized). The biggest thing Clojure I have not seen in the ones you pointed out is Program Transactional Memory .

Clojure was also designed for the JVM, as opposed to being a layer for another language, so it is slightly larger than "Java-y", which I suppose will be different when you need to interact.

Answer 5

If I were cynical, I would say, because Clojure got a nicer website and a sexier name.

Answer 6

The clojure.org substantiation section states:

Why did I write another programming language? Mostly because I wanted:

• A lisp
• for functional programming
• platform-mounted symbiotic
• for concurrency

and could not find it.

Do these 3 languages ​​you mentioned (Kawa, ABCL, and SISC) meet these requirements? It:

• Lisps (CL or Scheme dialogs) ✓
• for functional programming ✓
• Platform Installed Symbiotic (JVM) ✓

but they are not intended for (STM) concurrency; however, to be fair and complete, there are at least two STM libraries that I have found for the CL that have not yet been mentioned:

• STMX
  • Tested on ABCL. Under active development.
• CL-STM
  • Dead? The last change was in 2007.

Hmm ... So why create a new Lisp? Mostly because these are libraries. The rationale page on clojure.org continues (highlighted by me):

What about standard Lisps (Common Lisp and Scheme)?

• Low / standard standard standardization
• Core data structures are mutable, not extensible
• No concurrency in specs
• Good implementations already exist for the JVM (ABCL, Kawa, SISC, etc.)
• Standard Lisp are their own platforms.

It is a concurrency design language , as others have noted.

Also, why dwell on the JVM? Clojure Support for the CLR is under active development .

These are two gaps that he fills, from my point of view. You should use Clojure if it suits your needs. Do not worry about losing skills if Clojure falls off the map. Your Lisp skills, but more importantly your way of thinking, carry over to other Lisp dialects.

Answer 7

I should also add that Clojure is a relatively new language implemented by one person, with good marketing skills and great energy. He puts a lot of time and hype into Clojure ... sometimes hype is a self-fulfilling prophecy that if you can convince enough people that this is the last thing, then you can get enough support and momentum to make it really work.

I suspect Kawa performers, etc. not many are at stake, therefore, do not inflate your product. In addition, what is there to joke? "We have a great language .. it's called Lisp." It's harder to sell.

I think Java is a prime example of this. It had some very serious flaws, but since it was sold and hyped so much, it reached a large number of impulses, which meant supporting hardware and software suppliers, tool manufacturers, industry investments, etc. In any case, it achieved a certain degree of success, although I hated programming in it. Clojure can achieve similar success when other Lisps do not.

Answer 8

The advantage of Clojure is that it gives you access to all java libraries / code and multi-threaded support, as it is based on the JVM. In addition, it was designed with concurrency in mind, which was not usually developed in lisp, although due to display primitives, it would probably not be easy to design a lisp that supports concurrency.

In doing so, I tried Clojure and hated the syntax and pain in the butt, which seemed to combine with something related to Java.

Answer 9

Clojure is "a lisp", it is not any lisp that you already know. I spent the last couple of days reading material and watching videos, and I am impressed. it is suggested that functional programs (based on immutable data) are the best way to control concurrency. Clojure implements a lisp-like JVM-based system to provide it.

Answer 10

We do not need to have one more answer (and I do not expect a vote for it), but here are some small improvements for a few other answers.

Newer is not necessarily better. A newer and poorly designed one is not good, newer and not supported, it is not good, and newer without a larger (or at least growing) user community is not very good. (New languages ​​come out regularly, but most of them fall on the sidelines due to non-use.)

I like Common Lisp. Part of its beauty is its quirkiness, which comes from the fact that it was developed by committees with the goal of backward compatibility with several incompatible dialects.

I like Scheme. It is a beautiful, elegant language. However, its development depended on the committees, and perhaps this from time to time slowed it down. In any case, his goals are different from those of Clojure.

Common Lisp and schema have accents such as tail recursion that are not suitable for JVM efficiency. Clojure was designed from the start to display the JVM well and interact well with Java. (I'm not sure what this means about the dialects of Clojurescript and CLR.)

The fact that Clojure was originally developed by one person, Rich Hickey and controlled by him along with a small team, does not necessarily make it better than committee-controlled language. If one person made bad decisions, Clojure would not be a good language.

However, this is an important point : Hickey has developed a language that is well thought out, elegant and from the very beginning includes a systematically related set of functions that simplifies the execution of a lot with a bit. This applies to the core JVM interaction, as well as the rest of the language. The people who control Clojure still adhere strictly to language goals.

This is much of what I like about Clojure: it is well designed both in general and in detail. This means that as soon as you get used to it, program it with pleasure.

It would be a little exaggeration (or an understatement?) To say that Clojure has the power of Common Lisp with the elegance of Schema. Generic Lisp has a lot and a lot of what you need to embed in the language, but it's a mess (I say it with love), and when you need something more than the language, sometimes there are several incompatible libraries with various compromises. The design is small, although there are libraries. Clojure has a growing number of standard libraries (unlike CL), which are more or less parts of the language. A good illustration of this is the core.matrix project, which provides a common interface for several different matrix implementations. This is important because there are various matrix implementations that are best suited for the occasional use of small matrices or, for example, for the widespread use of huge matrices.

None of this means that Clojure is better than Common Lisp or Scheme; Not this. These three languages ​​have different virtues.

Answer 11

This is new! This means that not many old sheets will use it, since the traditional lisp community is good, traditional, but it also means that people with no previous lisp experience will perceive it as new.

Imho, Clojure is an older Lisps than Ruby was for Smalltalk. Not necessarily better, but good enough. And what’s important, it’s more suitable for your employer, because it has an impulse and is seen as a growing language, as Ruby once was.