... to Toccata. A computer programming language inspired by Clojure
I discovered Clojure very shortly after Rich went public with it and loved it from the beginning. But none of my previous programming experience was in Java or on the JVM and I always wanted a Clojure that compiled to native code. Several years ago, I set out to build exactly that. As I worked on it, I kept making tweaks to that took it farther away from a faithful port of Clojure. Eventually, I accepted the obvious and admitted that I was creating a language that was inspired by Clojure, but wasn't Clojure. Toccata is that language.
Why am I creating yet another language? Because the perfect language has not been created yet. Not that Toccata is going to be it, but as long as the perfect isn't here, there's room for improvement. I'd like to see the software industry write better code, that's more correct and do it faster with less effort. And I want better a tool to create with.
'Nuf said (sexprs are awesome!!)
With a little added syntax
Syntax in a language is like salt in cooking. A little bit makes the dish much better. Too much ruins it. Clojure seems to the sweetspot for LISP's.
Immutable data structures by default.
Again, Clojure really nailed this feature. It's amazing how, once you get used to it, you never want to go back to mutable values.
Compiles to C
This is the first issue I have with Clojure. I think Rich was right to target the JVM. But that decision also comes with a lot of overhead.
Core library built on top of common interfaces
Clojure's protocols are a great idea. It would have been very interesting to see what Clojure would look like if they'd been invented first. But they weren't, so Clojure is stuck with the burden of maintaining backwards compatibility. I find there's an ad-hoc feeling to the various functions in the core library that disappears when everything is built a set of common interfaces.
Good concurrency constructs
In my experience, most code is single threaded. But when you do need multi-threaded concurrency, Clojure's constructs are great. Having those same constructs, but with a common abstraction is even better.
Focus on building tools to aid in developing programs.
No language, now matter how perfect, is enough. To really be productive, programmers need tools that brings the power of the machine to the task of writing, debugging, and (most of all) reading/understanding code. In Toccata, the exact same libraries that the compiler uses are available as libraries so that anyone can easily write tools to work with Toccata source code.
And now ...
So this is the beginning of a long journey create the most productive programming language and ecosystem. Let's go.