Ask HN: Lispers: Which dialect of Lisp do you use and why?

If you're interested in Clojure, I _highly_ recommend /r/Clojure on Reddit. It's very active; several library devs, book authors, and core maintainers frequently post and comment. There's a weekly thread dedicated to new Clojure users ([Latest thread here][1]). The Clojure Slack[6] is even more active if you have a burning question.

If you would like to dip your toes in the water, 4Clojure[2] is an online interactive Clojure Kata. There's also a (nearly) full REPL environment at Try Clojure[3] or repl.it[4]. The Clojure Cheatsheet[5] makes it easy to browse and discover the Clojure standard library, and IMHO is _so_ well organized!

But the biggest part of Lisp is the interactive development. You really have to see it, and I love showing the [Bruce's Figwheel project presentation][7] because it's a very visual demonstration of what hot-reloading code and interactive development can bring. It also helps that he's doing Clojurescript in a live browser for web development.

[1]: https://www.reddit.com/r/Clojure/comments/6tq8f5/new_clojuri...

[2]: http://www.4clojure.com

[3]: http://www.tryclj.com/

[4]: https://repl.it/languages/clojure

[5]: https://clojure.org/api/cheatsheet

[6]: http://clojurians.net/

[7]: https://www.youtube.com/watch?v=j-kj2qwJa_E

Soooo...less awesome?

"Practical Common Lisp", available online. Great book.

Also if you want to have nice silly fun, take a look at "Land of Lisp" which IMHO is destined to become a classic.

Common Lisp.

It has standarized, well-documented, proven-for-decades way of doing necessary, common day to day stuff like conditions and restarts (aka "exception handling"), package system, or object-oriented-programming. Consider, for example, that Scheme has no standard way of organizing your code into packages and namespaces. Nor standard exception handling system; you are expected to use a lib, use what the particular Scheme implementation you are using offers or roll your own using the (extremely powerful) continuations feature. Scheme also doesn't have a standard OOP system like CLOS. You can implement all of this in Scheme, but Common Lisp has this standarized, proven, well-documented way for all of that. This makes reading others' people code easily, because common stuff is going to be done in a standard way that you already know.

It is a Lisp-2 which, for me, makes programming comfortable. People always talk about how macros in Common Lisp are "unhygienic" by default, but it is trivially easy to write a hygienic macro on Common Lisp.

It is an ANSI standard and the Common Lisp implementations largely comply with the standard, which means that I can take my code and run it with no changes (or very slight changes) on awesome Lisp implementations like LispWorks, SBCL, CLISP and many others.

There is a big amount of documentation available and in the last 10 years the amount of libraries, books and tooling has increased to make CL programming nicer than ever.

The implementations can be really high performance. SBCL can be had for free and it's performance is awesome. It is amazing that a dynamic programming language could be that fast. Also the implementations are mostly very nice to the programmer.

Common Lisp also allows to do low-level stuff if you like, for example it has full support for bitwise binary manipulation. Numeric support is magnificent and standarized: All CL implementations support real, fractional, complex, int, arbitrary precision numbers, and work with them really quickly.

Clojure seems more limited compared to Scheme or Common Lisp, being tailored for doing everything the functional way; while both CL and Scheme allow you to be 'eclectic' and use whatever programming paradigm the situation calls for.