...is indeed what I am working on. :)

Not yet ready for prime time, but I think I've got something that will be moby fun to hack with when it is.

There are a couple. First of all, I wanted to write a language to use as part of my "portfolio" to get into grad school.

Since I didn't want to waste my time on building yet another toy language, I thought about what I really wanted from a programming language, and deciding to actually implement it. I do a lot of exploratory programming, and it's my experience that I need three key features to go as fast as possible.

1. I wanted support for functional programming. Higher-order functions (blocks to a Smalltalker) are an essential tool for avoiding code duplication, because they let you abstract common patterns of execution. They also let you reduce the size of your program's class hierarchy, because you can use first-class functions to parameterize behaviors. Both of these make programs more compact, and hence easier to understand and modify.

2. I wanted support for OO-style subclassing. When doing exploratory programming, I want to be able to extend existing datatypes as needed. In a functional language like Haskell or ML, this isn't possible -- one must edit the original datatype declaration and all of the code that uses it. This kind of sucks.

3. I wanted a generic function/multimethod based OO system. This solves the binary method problem completely, and makes extending existing classes with new behavior very easy. The Visitor pattern just vanishes, for example. Furthermore, being able to extend existing classes in a disciplined way lets you avoid adding useless subclasses to your system, and making messages first-class function values lets you integrate OO and FP easily. This makes programs smaller and easier to modify, again.

4. I wanted static typing with type inference. IMO, type inference is one of the most amazing technlogies out there. You get all of the benefits of static type-checking with almost none of the costs, with the additional benefit that when you are doing experimental programming you can use type errors as a tool to help figure out what the structure of your program should be.

I've used languages like Dylan, which support everything I want but #4, and languages like Ocaml, which give me everything but #3. In each case I found myself missing either generic functions or static type inference.

Finally, I wanted to write a language that would let me replace Python as my tool of choice for quick hacks. For example, I like Ocaml more than I like Python, but I turn instinctivly to Python for quick hacks because Python has a very clean set of libraries, and Ocaml has a rather irregular and quirky set of libraries. I want to write a FPL that took its direction from the practicality and pragmatism of the scripting languages -- I'd like to help bring the sheer speed and fun of statically typed OO languages to the scripting world.