I tried a bunch of other lisps but disliked them for various reasons. Clojure is nice because of the tooling, but I disliked being tied to the JVM and all what that means.
CL has some very nice implementations (Allegro CL has a limited free version that has forever changed how I think a programming environment should be).
In the end I found guile scheme which is great. The threading situation is good and getting better, the language has all the comfortable srfi's that implementations like chez lack, and it has nice community.
The reason I chose guile over chicken was the r6rs compatibility, which made supporting both chez and guile rather easy. Other than that, I'd say that the chicken community is probably the nicest one online. Chicken is really a fine scheme as well.
I am not a programmer though, and what I want is for programming to be just fun. Not enterprise ready, not web6.0-cool. just fun.
Shameless self-plug: I just finished my racket-like for l-loops for guile: https://bitbucket.org/bjoli/guile-for-loops
I also spend some time with clojure around the time of v1.0-1.2 and quite liked it, but it's maturity level and the JVM made it less attractive in the long run.
I like scheme as well, but because of the spartan(to use a nice word) spec, If I actually want to get stuff done I'd have to chose just one implementation and it's associated libraries, rather than rely on portable code.
Simple, strongly typed, and really really easy to write and read.
On top of that, its fairly easy to compile as well, which gets rid of a bunch of distribution problems that come with other Lisps.
My first in-production experience was converting a monolithic Python web app to Scheme.
We wrote a library that brought a lot of Python conventions over to make things easier. Like an import macro that automatically namespaces things. (And we copied Clojure's "->)" macro for closing all open parentheses).
Total conversion for ~18,000 LOC Python to ~7,000 LOC Scheme took about nine weeks. The speed-up was about 2.5x.
And despite the much smaller codebase for Scheme - we actually added a whole heap of features, whilst matching all old features. (A bug or two as well, but that's to be expected).
Scheme is just really well suited to parsing, and rewriting itself as necessary.
So far as I'm aware, that stack is still running three years later, so Scheme wasn't just a fad for the team (who picked it up in about a week or so).
You should really do a blog post on this and submit it to HN! So people could appreciate the real-world benefits of using a Lisp.
Because Scheme has something utterly amazing, that I've seen in very few modern languages.
A safe eval function.
(let foo foo
(eval '(foo arg) (null-environment)))
Scheme also provides string->symbol and symbol->string type conversions, which allow you to do things that are normally next to impossible, though mainly only useful in macros.
That can let you generate let-bindings on the fly, which if you contain them with a safe eval, gives you some really amazing possibilities.
Like parsing and binding URL queries.
Development is slower than most, because it's mostly a one-man operation, but it's fast, can statically compile, can make tiny binaries and is mostly compliant, and the dev fixes compliance/bugs fairly quickly.
Docs can be lacking at times, but the code is fairly clear.
Handbook of Neuroevolution Through Erlang by Gene Sher makes a compelling argument (with detailed, varied examples) that Erlang is the perfect language with which to implement neural nets.
Lisp has always been associated with AI, of course. Nowadays it's all Python, Java and R for machine learning, but Lisp can do just as well, plus more: Lisp has an affinity for recursion, and its homoiconicity will - I suspect - prove fundamental for true AI. One can't just 'strap on' its features to those other languages (including Elixir: https://news.ycombinator.com/item?id=7623991).
So, obviously the right tool for the job is LFE!
I'm very happy with Guile and its performance has greatly been improved with version 2.2 (not that performance was a problem before); one thing I miss in Guile is the picture language that Racket comes with.
Common Lisp is well-optimized for application programming. It has excellent compilers, and good debugging support.
TXR Lisp is geared toward scripting; it is a very agile, ergonomic Lisp dialect. It has minimal dependencies and builds as a single executable with some satellite library files in your /usr/share tree, yet is loaded with features.
TXR Lisp is a Lisp-2, but thanks to a square bracket notation, the coder can seamlessly shift into Lisp-1 style programming with higher order functions. Though it has the equivalent of CL's funcall function and function operator, they are almost never used, and there is no #' (hash quote) notation at all.
I am currently working on the aarch64 (64 bit ARM) port of TXR which I hope to be able to include in version 184.
I started the TXR project around this time of year in 2009, which makes it 8 years old now.
For over a decade I wrote mainly in C++ doing a lot of Windows programming, usually games or simulations. Mix in some VB and C# when I didn't want to battle the Win32 API. I was used to seeing codebases with 100k+ loc and hundreds of megabytes of code files. xkcd COMPILING is real!
While working at BitTorrent in 2013, a coworker back introduced me to his little server that distributes uTorrent executable to everybody. It was an implementation of this[1] paper for a general purpose rules-based engine with a snappy (Clojurescript?) front-end. The whole thing was ~5k loc, and ran on surprisingly small hardware compared to it's traffic.
From there I was hooked. My project sizes are radically smaller, it's LISP, and I can go wherever Java goes. I wrote about my experiences with AWS Lambdas last year [2], for example. The community itself is outstanding. They are some of the nicest people you will ever meet. Because the community focuses on small libraries that are composable, those libraries become remarkably stable. Several heavily used libraries haven't had commits in months or years.
[1]: http://moscova.inria.fr/~maranget/papers/ml05e-maranget.pdf
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...
[4]: https://repl.it/languages/clojure
Also if you want to have nice silly fun, take a look at "Land of Lisp" which IMHO is destined to become a classic.
The ecosystem is great. I wouldn't use it for anything big on prod though, but it's easy to experiment with and is fun.
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.
It has Pulsar, which is miles ahead of any other lisp's threading abilities.
I wish it had a more mature static typing story, but I guess you can't have everything.
What about Lisp Flavored Erlang (LFE)? It was designed for concurrency.
You can argue Clisp is easier to get a quick project going with, but short of that rather old project nothing with a setup any less capable than "lein new" is going to compare for dashing something out real quick.
With rpm or apt it works of course, but doesn't feed my interest. clisp also fails on many systems (e.g. libsigsegv on win64), but there I can at least hack it away.
Cheating because it's not a lisp. But it was created by a schemer who originally put scheme in the browser (before he created javascript). Not what I prefer, but it's the most lisp-like language I actually use in real projects. The support for closures, lisp-1 invoking functions from variables, and dynamic typing feel very scheme-like.
http://journal.stuffwithstuff.com/2013/07/18/javascript-isnt...
McCarthy's first Lisp programs were written in MLISP notation.