Web 3d.0 Oooh! Teh shiney!

It's been a long and winding road that lead me to Nu, a very different destination and yet an inevitable one. Rather than the exuberance of darting from one language to another with the energy of youth, I'm an old fart who tries to do more with less.

I learned to write programs in BASIC. This damaged me, or saved me; for it created a deep appreciation of having an immediate response when I tell the computer to do something. I moved onto C after that, but always felt the lack of direct control compared to the edit-compile-run loop.

C++ did not win me over, and neither did Java. Perl was interpreted, and therefore lacking the speed I needed in places. Yet the pain of writing all application code in a lower level language was also an issue. Apple solved that problem by making Objective C a valid development environment.

Smalltalk is one of the great intellectual achievements in the field of programming languages. It was also rather slow. LISP is another great achievement, and also slow. And they both have the problem of all nice languages becoming ugly when optimised.

The best language is the one that provides a close mapping to the problem domain, yet brings things up to a level that is most comfortable to the human mind (respective to what is being done). The best language for a von Neumann hardware architecture is C.

The next layer of language engineering for the comfort of the human mind is to break problems up into objects. This metaphor is chosen by the efficiency of implementation, rather than other abstractions that can be expensive to achieve (eg, Prolog). The best language for objects is Smalltalk.

The problem with going between different layers of programming is the subtle variations caused by different things looking the same. So the solution is the initially unpleasant, yet actually correct and powerfully so, approach of combining languages that look as different as possible.

The merge of C and Smalltalk is Objective C, and the proof is in the results. Apple have used it to achieve what Microsoft could not. And yet even these amazing results doesn't stop my early BASIC brain damaged self from missing that immediate response to my direct control.

Domain Specific Languages (DSL) are becoming very popular right now. So why not add a scripting layer that gives me an extra level of control? F-Script was promising, but it was C + Smalltalk + Smalltalk, and I wanted more so that it would be worth that extra layer.

So the first time I saw code in Nu, I was amazed at how well the merge between the two worked. In the same way that Objective C bridges between two very different environments, Nu achieved the merge of Smalltalk into LISP, with C as the common ground.

Nu tries to be as much like Objective C as possible, and yet is still obviously LISP. That provides the context for mentally switching to a third language, and the very low cognitive overhead of using what you already know makes Nu an easy and very powerful addition.

Nu is a clever mathematical pun, with the best URL, http://programming.nu ... it means "C over lambda", and that is exactly what it means. Nu is a full LISP and has no problems implementing macros and lambda or anything else. However it is very different from pure LISP, as objects are the fundamental construct.

LISP is based around lists and values. Nu is based around lists and objects. Everything in Nu is an object. Even numbers are objects. And these objects aren't expensive abstractions that only work fast enough with small amounts of test data. They have the solidity of real metal behind them, written in C.

By selecting from a base of stable components, Nu is also a stable mature programming environment despite being so young. It is already possible to write enterprise applications with these tools because the significant portions are not new, and the language itself is not original.

See for yourself:

http://blog.neontology.com/posts/2008/02/24/scripting-nsoperations-with-nu

and LISP abilities:

http://blog.neontology.com/posts/2008/01/13/y-combinator

Yet this very thin layer allows me to drop code down to Objective C, or down to C, or down to assembler. It lets me call sideways to OpenGL or Apple's various Core libraries. I can whip out my copy of SICP and implement Prolog on top of my existing code. I can use macros to write real DSLs for any part of my code.

The results are stunning. Strawberries, chocolate and cream go together like C, Smalltalk and LISP. Add some slices of Apple and Cocoa on a Quartz and OpenGL platter and it's irresistible! The disadvantages of LISP are balanced out by the advantages of Smalltalk. The slowness of both is removed by the ability to drop to C.

And add the blue vein cheese of Linux... ok, that's taking the analogy a bit too far. :)