Ask HN: Which Lisp/Scheme to go for?

https://news.ycombinator.com/item?id=12060734

by ngeek_13 • 10 years ago

8 12 10 years ago

news.ycombinator.com

I like Lisp/Scheme, but there are too many implementations and I'm so lost.

amirouche• 10 years ago

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/

znpy• 10 years ago

I wish Guile was as well-documented as Racket.

brudgers• 10 years ago

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

CyberFonic• 10 years ago

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• 10 years ago

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.

veddox2• 10 years ago

I taught myself CL with Touretzky, can recommend it.

veddox2• 10 years ago

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

gus_massa• 10 years ago

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

kogir• 10 years ago

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.

rubiquity• 10 years ago

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• 10 years ago

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

pori• 10 years ago

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.

Ask HN: Which Lisp/Scheme to go for?

Related Stories