I'm Simon, Englishman living in France. Been into computers since way before the original Beeb (my first machine was a Microtan65, if anyone remembers them, that I was given in assembled but not working state). Currently doing lots of low level stuff on ARM and other microcontrollers, along with some Ruby. Main project at the moment is this (old post to lambda-the-ultimate):
It's based on the idea that most people are carrying around more computing power than appeared in an early 90s developer workstation, but at best it's being used for playing Angry Birds or emulating flatulence at the push of a button. I figured it might be nice to use that processing power for something else. A loosely coupled, heterogenous computing platform able to pick up and throw away nodes as and when they "appear". It's actually a dream I've had for some time, but the ubiquity of smartphones, PDAs and other mobile computing platforms, coupled with the ease of proximity networking using bluetooth and other wireless tech means that it's more or less in reach. Modulo the need to change everyone's operating system and allow anyone to run untrusted code on your device, of course.
The concept is based around the idea of farming out bits of a given computing process as continuations, and then harvesting the results. The continuations themselves might migrate from node to node as required to get hold of resources, but the results should end up back with the user.
Continuations screamed Lisp (or something lispish) to me, and I have a protolanguage running over CCL that passes continuations from one instance to another and back fairly happily.
Platform wise, I decided to go with ARM, if only because I have this funky little ARM-based tablet that's not doing much, and a bunch of little ARM-based µC boards, also not doing much. If I decide to really hurt myself, I've got a few 8-bit µCs as well
. So what I needed was something that could act as a Lispish runtime on something as stripped down as an STM32F100 (the aforementioned 128K/8K platform, well under a dollar a piece in quantity); this is, in itself, an "interesting" exercise.
Where I'm at with the µC side of things is that I have an almost-lisp in under 1K (cons, car, cdr, cond, lambda, lookup, various predicates, all written as tightly as I can in assembler, although I'm certain there's a good few bytes to shave off here and there as I'm a relative beginner with ARM and Thumb2 in particular), a very memory-miserly type system, and a bunch of support code. It's almost at the stage where the runtime can bootstrap itself (and eat all available RAM, as it's without GC at the moment).
Things have moved on from there, I have a system up and running on STM32 (although the compiler is still hosted on a "big box") that has a REPL and will accept and perform compiled code passed in from elsewhere.
RasPi interests me as a low-cost, low-power "developer box". I've always favoured functional languages over imperative as a teaching tool, an "on the metal" OS that's programmed from the ground up using FP might be of interest to the educational community too.
So, that's me.