Ask HN: Which Lisp/Scheme to go for?

I vote for Racket. It's a scheme "dialect" (actually, it's officially a different language, but it's very close). It has a lot of libraries ("battery included") a nice IDE and extensive documentation. (for example, from the starter guide https://docs.racket-lang.org/quick/index.html )

Also, the idiomatic code is mostly functional, but you can write non functional code if necessary.

(And if you want more confusion, add Clojure to the Common Lisp / Scheme list. It's another similar language with lot of parenthesis. It's somewhat similar to Scheme but the difference is big enough to tell them apart easily. And it runs in the JVM.)

I recommend you try/use GNU Guile. It's a Scheme which has better grounds that other lisp language. Among Scheme language, it stands out with good support for foreign function interface (ffi), support for OOP, a good support of standards (r6rs and various srfi and r7rs support is in the work). There's a real community. Recently support for asynchronous code was added through fibers project [0] which makes the use of non-blocking socket (almost?) transparent otherwise said you can use the same procedures in asynchronous or non asynchronous code. There is opengl bindings and a 2D framework called sly with which you can do live coding. There is simple but efficient libraries for doing web apps. A more advanced option is to use Artanis [1]. And some people are working on better array operations to match numpy for doing matrix operations.

This is not Python tho. There is not as much people or library. Package sharing is different, it's mostly done through guix/sd or copy/pasting (!) modules in your projects (at least that's what I do and it works). Otherwise said, there isn't a solid equivalent to pypi outside guix...

BTW, guix is a an functional package manager where guixsd is distribution built on top of it [2].

Also, it's a GNU project which means your contribution won't be lost in the sea; join a community dedicated to building ((good) free) softwares that can make a difference and where you can make the difference.

HTH!

[0] https://github.com/wingo/fibers [1] https://github.com/nalaginrut/artanis [2] https://www.gnu.org/software/guix/

Depends on what you want to use Scheme for.

Racket - wide support, ease of use, etc.

GNU Guile - extending GNU applications or building your own robust ones.

Chibi - embedded applications. (My personal favorite.)

If you mean "Lisp" as in more general than Scheme, then the main two are:

Common Lisp - most used, advanced, etc.

Clojure - most popular of all the lisps today, arguably. It has the largest ecosystem thanks to JVM interoperability.

Scheme is probably the "purest" Lisp around, but unfortunately is not very big (it's more of a learning language than a production one).

Personally I would recommend Common Lisp: it's one of the older dialects, has a solid standard definition, a fairly large community and you can easily download a lot of packages via Quicklisp. Plus, several important Lisp books (including PG's "On Lisp") use it as a reference dialect. As an implementation, SBCL is the most popular, though CLISP isn't bad either.

Alternately, you could try out Clojure, this has all the advantages that come with being built on top of the Java virtual machine.

I don't have any experience with GNU Guile or Racket, but I get the impression their following is still very small (especially for Guile).

Yes, there are a lot of implementations, but in principle they are very similar. The big divide is between Common Lisp and Scheme. For learning Scheme has the edge, principally because of educational books like SCIP. CL is more widely used for production code.

GNU Guile is good. However, I think Racket has better documentation and learning resources. Both CL and Scheme are defined by standards so once you are familiar with one implementation you can pick up another with minimal learning curve.

I just went through this when deciding to finally work through The Little/Seasoned/Reasoned Schemer books. After spending way too much time stressing the implementation I settled on (Petite) Chez Scheme. It was super easy to install, has great docs/guide, and works quite fast.

My advice would be to just pick one and don't look back. I spent way too much time on it that should have been spent learning.

Have you consider clojure? It is growing a lot and it is possible to find job in clojure, the clojure team is doing a lot of interesting works on the language...