Differences between LISPs and which to learn?

tell me pls

use this one: http://racket-lang.org/

Racket a shit. Use this one: http://callcc.org/

All LISP dialects have been replaced by Symta.

we do not forgive
we do not forget
expect us

- GNAA

I heard the two things below, /prog/. Which one is correct?

1. The C-C++ relationship is similar to that of Scheme-CL (respectively).

2. Scheme is more a toy/educational language whereas CL is the one to be used in general and real work.

>>6
2

Learn Clojure, then realize Haskell is superior and forget about LISP.

>>8
Haskell is a disgusting useless piece of badly engineered shit.

This shit has been beaten to death over the course of decades.

Scheme - reading SICP. Read SICP. There are, like, three guys in the world also use it for scripting and plugins. Lots of implementations, about three that matter.

Common Lisp - big, hairy, industrial, fugly. Bigger libraries, good performance, very flexible, and an eyesore.

Racket - Scheme with more features, actual libraries and bundled with a mock-IDE.

Clojure - functional programming fetishism, easy Java turkey interop, more libraries in both Clojure and Java than the others. Has UGLY AS FUCK stacktraces.

Haskell would be better without the dependency hell.

>>6
Neither.

>>1,6
Differences:
1. One has this thing going for it that it has a humongous spec that brings homogeneity to all the implementations in a COBOL-like fashion. Unlike COBOL, this thing's spec is frozen in time and will have to carry the burden of its design flaws for millenia. If this thing ever perishes it will be from its near homogeneity.

2. The other was born from an academic exercise in computation, a 50 page spec documents it roughly every 10 years. Every implementation of this one is in fact, a completely different lisp that happens to have functions in common, this is good for speciating the language into niches and if its a permissively-licensed open source lisp, who cares about standards (the other scripting languages don't even have any). Other than the aforementioned 50 page spec there are bite-sized RFCs with code to maintain some new features across implementations, though these sometimes don't get consensus because someone points out the functionality won't be possible on his potatoe powered lisp machine, or "this is an american term, we should use this french term instead", etc. They are either compilers, scripting engines and a scant few are image-based, the spec doesn't put restrictions on what it can be really.

3. Another is an evident fork in philosophy that sparked off from the sixth revision of #2's spec. The seventh upcoming report will mean that #2 will now become #2 and #3. #3 is a superset of #2, it will perhaps be this generation's #1.

4. The other lisps tries to "improve" #2 and give it a completely new name to wow the reddits of their grand invention.

5. A few exists for no other reason than that portable scripting language libraries hadn't happened yet at the time they were implemented.

6. The rest existed without knowing about #2 and probably half assed anything resembling #1 as well.

>>10

Is Scheme really so ``small'', as in, I can't use it for general programming and big projects?

What would you recommend? Common Lisp seems bloated.

>>12

So, #2 and #3 and going to fuse and have the same purpose of #1?

And we will have two similar LISPs that satisfy #1's character?

What is #1, #2 and #3? Why, how and when will #2 and #3 fuse?

>>13
``Scheme'' the language as specified up until R5RS, pretty much yes. It has neither modules, nor records, not even hash tables,  nothing in the way of ad-hoc polymorphism, etc.

``Scheme'' the language as implemented by e.g. Chicken Scheme, is another matter entirely. These may sport their own IO APIs, module system, record system, custom macro syntax, and many other things you may need for programming applications, in a way which is in no-way guaranteed to be compatible with other implementations, e.g. Gauche. This may not matter to you as an application developer, save for the library fragmentation.

I know very little of Common Lisp. Can't comment any further, other than that SBCL seems to be the most popular implementation.

I have (and am currently using) Clojure. It's pretty full-featured and has some pretty good tools in the form of Leiningen (awesome) and the usual Emacs ecosystem/hodgepodge which supports Lisp programming. Like other JVM languages, it can call Java libraries seamlessly, so even if they are a bit unsightly, you'll always have ample fallback if you don't find what you need ``natively''.

I would recommend you this: learn a bit of Scheme to get the feel of this ``Lisp'' thing, then move to Clojure. Otherwise, getting married to a particular Scheme or Common Lisp implementation may be fine, but that's just my bias, ``backed'' by hype (which means that its community is growing).

age