Your favorite implementation?

Seems a proper enough topic for the first thread in the Scheme subforum.

So what's you favorite implementation, and why?

PLT Scheme. It works well on several platforms, has lots of libraries, good FFI and is in general well thought out and solid package. It is not the fastest Scheme around but I find it easier to work with than the compiling-to-c implementations.

I don't much care for the DrScheme environment but mzscheme/mred works fairly well from Emacs.

scheme48, because scsh, the scheme shell uses the VM of it. and, of course, Guile - because i am GNU/Debian user and it provides as far as i can see the best interface to C and implements a great part of the POSIX stuff from scsh (sockets, threads et c.). it provides also quite a good console-environment with debugger and the ability to backtrace (same as with MITscheme and Drscheme, i guess). for emacs i use the cmuscheme-package , which has great syntax highlighting and never let me down yet...i got also some of the Sunterlib packages, but was too stupid to get them installed properly. there a also a lot of stuff for generating html and parse xml on Oleg Kieselov's page i have downloaded and want to test in the nearer future. would be a great thing, if someone experienced writes an scheme-module for the nginx server. the server itself is poorly documented, but there is a tutorial in english for the module environment.

PLT is my favorite for simple things. I've unfortunately never had the opportunity to use it for a large project, but it's module system seem like it could handle the job.

PLT 4.0 just came out, and it seems as good as anything they've put out so far. I don't know the differences, but I'm using it instead of 372.

I'm enjoying SISC ( http://sisc-scheme.org/ ) because it allows me to interface with lots of Java libraries.

My preferred implementation is SCM though, with SLIB ( http://www-swiss.ai.mit.edu/~jaffer/SCM.html )

I like Gambit-C Scheme in its approach; being portable to all sorts of platforms as long as a good C compiler is available. But as a newbie to both CL and Scheme, I'll probably spend more time using the prepackaged PLT/DrScheme environment with its pretty GUI stuff, for now anyway.

I haven't done much scheme coding (only examples from the SICP, but they were running only in MIT Scheme), but tried STALIN on couple of example and was impressed by the code generation (granted, not the standard way to use lisp/scheme, having compile times of hours/days, rather than ms, but still impressive).

Chicken Scheme. It is also a Scheme-to-C compiler, and has a very flexible and convenient foreign function interface. To me, Chicken is the most pragmatic Scheme implementation because there is a huge number of practical libraries available for it, and it is quite easy to create an interface to any C or C++ library.

malkia wrote:I haven't done much scheme coding (only examples from the SICP, but they were running only in MIT Scheme), but tried STALIN on couple of example and was impressed by the code generation (granted, not the standard way to use lisp/scheme, having compile times of hours/days, rather than ms, but still impressive).

I tried Stalin yesterday, but killed it after it had spent about 5 minutes (possibly) compiling an example benchmark with no visible output. I wish it would write something to the console periodically about what it was doing; I assumed it had hung

I like MIT/GNU Scheme. The Pros are that it has a pretty good compiler so you can make it run fast. The Cons are limited documentation and tiny heap size on Windows.

I like Guile - because it is the only Scheme Implementation i have ever really used for something. And i think stalin is interesting - the code stalin generates is somehow ... frightening.

Through its robustness, performance, extensive debugging features, clustering functionality, expert community, and through being open source, Gambit Scheme http://www.iro.umontreal.ca/~gambit/ is certainly a very strong candidate. An extensive module system is underway, easing incremental development processes for large projects.

Ikarus http://www.cs.indiana.edu/~aghuloum/ikarus/ is interesting by being one of the industry's most sophisticated incremental compilers. It has very high potential upside in performance, though may not score highest in debuggability features. The commercial analogue to Ikarus is Chez Scheme http://www.scheme.com/ .

TinyScheme http://tinyscheme.sourceforge.net/ is interesting through being a small interpreter environment.

Bigloo http://www-sop.inria.fr/mimosa/fp/Bigloo/ is interesting through generating small binaries.

SISC http://sisc-scheme.org/ is interesting through providing a complete R5RS Scheme environment atop Java.

Scheme generally signifies itself by its many high quality implementations, including Chicken http://www.call-with-current-continuation.org/ , PLT http://plt-scheme.org/ , MIT http://groups.csail.mit.edu/mac/projects/scheme/ , Gauche http://practical-scheme.net/gauche/ , and many others, as well.

In terms of pre-built libraries, it may be that PLT and Chicken score the highest. Though, like when planning any technology project, you need to ask yourself what libraries are relevant to you, and what purpose they should fill, in detail.

Generally speaking, Scheme implementations differentiate themselves through

- how they execute code (direct compilation to binary code such as X86 binary code or JIT, compilation to another language such as C, C++ or Javascript, incremental compilation, interpretation)
- how they do threading (green threading, operating system threads such as pthreads, none, mixed)
- if they fully support continuations
- how R5RS and/or R6RS compliant they are
- how performant they are
- how robust they are
- what debuggability features they have
- how deep operating system integration they have, and for what operating systems

Scheme has the world's highest number of high-quality software development environments for one and the same programming language.

I favor PLT Scheme because it contains a lot of stuff and is rather well documented. And the mailing list is great for asking questions.