scheme vs common lisp vs racket vs clojure which should I dive

File: 1479857784611.gif (1MB, 250x188px) Image search: [Google]

1MB, 250x188px

bump

>>57726151
scheme

guile

>>57726741
why?

>>57726874
because scheme is becoming the new python

>>57727361
I though python was a bad language.

>>57726151
Racket is one of the best languages I've ever worked in. It's got the minimalism and good design sense of scheme without suffering from the lack of libraries like most schemes do. Higher-order modules make packaging and linking code in libraries a fucking breeze, especially compared to e.g. basic Scheme's complete lack of any official library support. The static typing system is supported with dynamic contracts, meaning you can mix statically typed code with dynamic code just by using modules and get the benefits of both. The pattern matching it provides is great, it's more fully-featured than Haskell's iirc. The standard and other libraries have a shit ton of things you can use, and it includes a GUI-abstraction kit so you can write a GUI for a program once and have it run on any platform (GTK, Cocoa, Windows) without headache. It's got some great people and really intelligent researchers behind it too (like the guy behind the Little Schemer series). The Racket Lisp runtime can be embedded in C and C++, and it's currently used by scripting by companies like Naughty Dog (Racket Lisp was used for scripting Last of Us and Uncharted) because of this. The language itself is on the forefront of at least two fields: gradual typing (via it's typing-contract interaction) and macros (via its phase-expansion macro system).

>Scheme
A good, small language. There's no official support for libraries, which makes maintaining large codebases really difficult. A lot of Scheme distributions come with their own incompatible libraries and you'll have to roll your own many times.

>Common Lisp
Old as hell but stable. LOTS of idiosyncrasies due to finding the lowest common denom. of competing Lisp implementations from <1980 (set vs setf vs setq vs... all do similar things and are superseded by one form but never got removed). Due to its age, many libraries aren't available via public git repos.

>Clojure
If you enjoy JVM error messages and Java libraries, here you are.

>>57728561
tell me more about the static and dynamic typing
and the pattern matching, how more sophisticated could it be

>>57728816
You can have a statically typed module and use it in a dynamically typed module. The math library in Racket, for example, is statically typed, but you can use it fine in dynamically typed code. The pattern matching has escapes and can evaluate arbitrary expressions before and during matches.

>>57729049
downloading it right now
is minimal racket enough?

>>57729074
Download the whole language. If you want to create minimal or small libraries, use #lang racket/base instead of #lang racket.

>>57728561
you sir got my attention.
this looks cool :)

>>57728561
shit, Just went to racket-lang, and it has lots of documentation

>>57729382
Yeah, it's a very well documented language. I don't think I've run into any function in the standard library that wasn't given type signatures, examples, and a description. It's nice because that standard for documentation bleeds into the community as well, leading to some really nicely documented and explained libraries.

>>57728561

This anon covered the case for Racket pretty well, so I'll try to provide more information on Scheme and Common Lisp.

First, information from other sources:

Andy Wingo has a list of scheme implementations by use-case here: https://wingolog.org/archives/2013/01/07/an-opinionated-guide-to-scheme-implementations

The Common Lisp Wiki (CLiki) has a list of CL implementations, with notable features, here: http://www.cliki.net/Common+Lisp+implementation

Scheme:
You won't really use Scheme, the language, as the language provided by the standard is too small to allow for libraries that work across implementations. You'll use whichever implementation works for your use case.

Common Lisp:
The standard for CL is large enough that you can write non-trivial applications using only what's in the standard. It is true that there are a number of features you would expect in a language which are absent from the standard (threading, networking), but most of these features have de-facto standard libraries (e.g., bordeaux-threads for threading, and usocket for networking). It's got a bit of a learning curve, but with slime (an emacs extension) and quicklisp (a library manager), I find CL to be a very comfy language. Practical Common Lisp is a pretty good introduction if you have previous programming experience.