So, Arc is out, in a very alpha form. Ignoring the whole debate over Unicode support, it seems that Arc is just a bunch of abbreviations and nice shortcuts on top of MzScheme.
Many people where expecting a lot more, but Paul Graham had it very difficult. For, you see, Lisp as a language can’t be improved. Every time something is added to Lisp, the result is, well, Lisp. In other language families, evolution is usually based on adding features:
C + classes = early C++
Early C++ + templates + exceptions= modern C++
But in the Lisp language family, adding a feature to Lisp gives Lisp:
Lisp + classes = Lisp
Lisp + exceptions = Lisp
Lisp + anything = Lisp
Why is Lisp so different in this? Because of its syntax, of course. When programming in Lisp, there’s no syntactic difference between what’s already in the language and what has been added afterwards. It was possible to use classes in C, what C++ did was provide a syntax to make an object system the default in the language. But in Lisp, thanks to prefix notation, macros and code-is-data, you can add one or many object systems without having to change the language. Scheme has about one object system for every Scheme programmer, and they all program in Scheme.
What you can improve in Lisp programming is the “programming” part. Going back to the C family, Java was an improvement because it came with automatic memory management, making programming a lot better in many situations. Some Lisps come with debuggers, and I like those a lot more than the ones that don’t. It’s curious how much language designers forget about the programming part. They’d rather add keywords than debugging facilities.
Will programming in Arc be better than programming directly on MzScheme? Maybe a little, as the shortcuts make Arc code a lot more compressed. But without improvements on the programming side, Arc is just another Lisp. For me, the best programming language, but not the best programming.