
Ask HN: Which Lisp/Scheme to go for? - ngeek_13
I like Lisp&#x2F;Scheme, but there are too many implementations and I&#x27;m so lost.
======
gus_massa
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](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.)

~~~
kogir
Racket's documentation is wonderful and the community around it is very
welcoming and helpful.

I'm a huge fan and my only wish is that it supported OS threads so it was
possible to fully utilize a machine with a single process.

------
amirouche
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](https://github.com/wingo/fibers) [1]
[https://github.com/nalaginrut/artanis](https://github.com/nalaginrut/artanis)
[2] [https://www.gnu.org/software/guix/](https://www.gnu.org/software/guix/)

~~~
znpy
I wish Guile was as well-documented as Racket.

~~~
brudgers
Documentation is one of Racket's killer features. There are very few language
communities with its quality of documentation.

------
pori
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.

------
veddox
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).

------
CyberFonic
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.

~~~
lispm
Scheme has an edge for education in computer science (which has different
goals than teaching you actual Lisp programming) over Common Lisp, because
there are some good books and courses based on Scheme.

For learning Lisp programming, Common Lisp has also extremely good books. Both
basic, mid-level and advanced.

Examples:

Touretzky, Common Lisp: A Gentle Introduction to Symbolic Computation

Barsky, Land of Lisp

Graham, ANSI Common Lisp

Graham, On Lisp

Winston/Horn, Lisp

Seibel, Practical Common Lisp

Weitz, Common Lisp Recipes

Norvig, Paradigms of Artificial Intelligence Programming, Case Studies in
Common Lisp

I would recommend each of these books to people who want to learn Lisp
programming or certain aspects of it.

~~~
veddox
I taught myself CL with Touretzky, can recommend it.

------
rubiquity
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.

------
siscia
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...

