As long-time readers will know, I’ve been working on and off on a project called JeeMon, which bills itself as:
JeeMon is a portable runtime for Physical Computing and Home Automation.
JeeMon packs a lot of functionality: first of all a programming language (Tcl) with built-in networking, event framework, internationalization, unlimited precision arithmetic, thread support, regular expressions, state triggers, introspection, coroutines, and more. But also a full GUI (Tk) and database (Metakit). It’s cross-platform, and it requires no installation, due to the fact that it’s based on a mechanism called Starkits.
I’ve built several version of this thing over the years, also for small ARM Linux boards, and due to its size, this thing really can go where most other scripting languages simply don’t fit – well under 1 Mb if you leave out Tk.
One of (many) things which never escaped into the wild, a complete Mac application which runs out of the box:
JeeMon was designed to be the substrate of a fairly generic event-based / networked “switchboard”. Middleware that sits between, well… everything really. With the platform-independent JeeRev being the collection of code to make the platform-dependent JeeMon core fly.
Many man-years have gone into this project, which included a group of students working together to create a first iteration of what is now called JeeBus 2010.
And now, I’m pulling the plug – development of JeeMon, JeeRev, and JeeBus has ended.
There are two reasons, both related to the Tcl programming language on which these projects were based:
- Tcl is not keeping up with what’s happening in the software world
- the general perception of what Tcl is about simply doesn’t match reality
The first issue is shared with a language such as Lisp, e.g. SBCL: brilliant concepts, implemented incredibly well, but so far ahead of the curve at the time that somehow, somewhere along the line, its curators stopped looking out the window to see the sweeping changes taking place out there. Things started off really well, at the cutting edge of what software was about – and then the center of the universe moved. To mobile and embedded systems, for one.
The second issue is that to this day, many people with programming experience have essentially no clue what Tcl is about. Some say it has no datatypes, has no standard OO system, is inefficient, is hard to read, and is not being used anymore. All of it is refutable, but it’s clearly a lost battle when the debate is about lack of drawbacks instead of advantages and trade-offs. The mix of functional programming with side-effects, automatic copy-on-write data sharing, cycle-free reference counting, implicit dual internal data representations, integrated event handling and async I/O, threads without race conditions, the Lisp’ish code-is-data equivalence… it all works together to hide a huge amount of detail from the programmer, yet I doubt that many people have ever heard about any of this. See also Paul Graham’s essay, in particular about what he calls the “Blub paradox”.
I don’t want to elaborate much further on all this, because it would frustrate me even more than it already does after my agonizing decision to move away from JeeMon. And I’d probably just step on other people’s toes anyway.
Because of all this, JeeMon never did get much traction, let alone evolve much via contributions from others.
Note that this isn’t about popularity but about momentum and relevance. And JeeMon now has neither.
If I had the time, I’d again try to design a new programming environment from scratch and have yet another go at databases. I’d really love to spend another decade on that – these topics are fascinating, and so far from “done”. Rattling the cage, combining existing ideas and adding new ones into the mix is such an addictive game to play.
But I don’t. You can’t build a Physical Computing house if you keep redesigning the hammer (or the nails!).
So, adieu JeeMon – you’ve been a fantastic learning experience (which I get to keep). I’ll fondly remember you.