NexJ Scheme is an open source project providing an efficient and powerful interpreter for the programming language Scheme that executes in a Java virtual machine.

Today I was sort of shocked to learn that there is another implementation besides SISC and Kawa that runs on Java!

There wasn’t even an announcement for NexJ on comp.lang.scheme and NexJ has been around for two years :(! Rather it was mentioned on scheme-reports this week.

Zombie-like, 6.001 rises from the dead to threaten students again. Unlike a zombie, though, it’s moving quite a bit faster than it did the first time. Like the original, don’t walk into the class expecting that it will teach you Scheme; instead, it attempts to teach thought patterns for computer science, and the structure and interpretation of computer programs. Three projects will be assigned and graded. Prereq: some programming experience; high confusion threshold.

(via MIT via keegan via planethaskell)

With virtually no iOS knowledge I just checked it out, built it, and ran it on the simulator in a couple of minutes.

Thank you Alex and Meng!

(via chibi-scheme)

(via comp.lang.scheme)

(via scheme-reports)

Whalesong is a compiler from Racket to JavaScript; it takes Racket programs and translates them so that they can run stand-alone on a user’s web browser. It should allow Racket programs to run with (hopefully!) little modification, and provide access through the foreign-function interface to native JavaScript APIs. The included runtime library supports the numeric tower, an image library, and a framework to program the web in functional event-driven style.

Suppose the answer is obvious but John summed it up well:

Well, if you interpret (apply + some-list) and (apply * some-other-list) as left-folds, then a starting point is needed, something to begin accumulating from. The identity is the only value that works correctly, so it’s what gets returned when the list being folded over has length 0. Nobody would write (+) or (*) explicitly, but having them return the identity is the Right Thing nevertheless.

The same argument applies when expanding macros: in a degenerate case, a macro may expand to (+) or (*), and it’s usually not appropriate to raise an exception.

I thought that pattern-matching was the best way to do it; and now I’m curious about why CA*D*R is better.

The following all intend to support R7RS small:

* Per Bothner (Kawa)
* Will Clinger (Larceny)
* Shiro Kawai (Gauche)
* Manuel Serrano (Bigloo) – “not sure about libraries”
* Alex Shinn (Chibi) – “already fully implemented, but lacking tests”
* Felix Winkelmann (Chicken)

The following were less committal, but open, and their
implementations are flexible enough to implement R7RS in
third-party code:

* Kent Dybvig (Chez) – “if it’s as simple as you say I don’t see why not”
* Matthew Flatt (Racket) – “if there’s sufficient user demand”
* Andy Wingo (Guile) – “probably”

The following are simply unable to implement R7RS or uninterested
in standards:

* Taylor Campbell (MIT) – “MIT lacks the infrastructure for modules”
* Jonathan Shapiro (TinyScheme) – thinks call/cc should be removed
* Jeffery Mark Siskind (Stalin) – “no longer working on Stalin”
* Michael Sperber (Scheme48) – “no time even for R6RS”

No one refused to implement based on the content of the standard,
or cited any features as showstoppers.

That last part is important; R6RS didn’t have that quality.

(via scheme-reports)