Lambda the Ultimate

The bigger the better, right? ;-)

Or I would be seriously worried about you... :-)

I was kidding, of course, but after writing this I began to wonder whether this attitude, so prevalent in our (?) culture, may not be one reason why "big" languages, with "big" libraries, are often considered better than "small" languages, even prior to any experience. A related aspect is the "vox populi, vox dei" sentiment, which leads to the assumption that a large language community (undoubtedly a good thing), is evidence enough that one language is superior to another.

Cultural criticism is beyond the scope of LtU, but since it makes no sense to assume technical attitudes are completely independent of cultural norms, I wonder if these factors don't play an important role in what seem to be technical arguments about language design.

One of the biggest issues with Scheme (and we do use it at our company) is the fact that although the basic language is the same, each implementation decides to take a different (and usually incompatible) stab at the same problems (such as namespace control, classes, modules, threads). Having code portable across implementations is quite a challenge, and thus limits the usability of the language.

As an example, MzScheme defines a nice model for event handling that brings a lot of issues to a common framework. But try moving that code over the Gambit-C to try and get the speed, and most of that needs to be rewritten or reimplemented.

Contrast this to Java, which because of the "big specification/implementation", has only a few implementations, and thus most 3rd party libraries are targetting the same platform, which allows for greater "reuse" by developers, and the ability to share code/comments/techniques to a much greater extent.

If Scheme (or any other "small language") were to develop a more common enforced library structure (and the SRFIs don't seem to be it), maybe there would be greater leverage, and a "small language" would appear to be large enough to support large projects, and garner a big enough community.

Major differences in R5RS from R4RS:

• Syntax-rules
• Multiple values
• dynamic-wind
• (if '() #t #f) => #t
• eval

For differences in R6RS, see the status report from June 2006 linked from here: http://schemers.org/Documents/Standards/Charter/.

Of course it's syntax-case that is added, while syntax-rules is being redefined in terms of syntax-case.

My comment about syntax-rules was about what was added in the Fifth report. In R6RS, syntax-case is added. However, the report does not define syntax-rules in terms of syntax-case, although a sample implementation that does that is provided.

Of course, they might retaliate with Common Lisp's 1300 page draft standard..

I believe the canonical version of that comment is done with Scheme and Common Lisp, where one could (allegedly; I haven't tried) fit the former's entire spec into the space taken by the index of the latter's.

This might no longer be true with R6RS, which seems a bit... big, relatively speaking.

Still, it's heartening to see that, as far as formal comments go, suggested simplifications are on par with defect reports and enhancement requests.

Without section 7, it is impossible to write a script that will run in any RnRS-compliant implementation.