Sub Ubi

It was an absolutely beautiful day today, so Carrie and I went over to Lake Waban on Wellesley’s campus to exercise. I managed a two mile run, and could have completed the circuit if I had known how close I was. (Oh, the mental games…)

This was partially just to get out and run, and partially because I hadn’t done any exercise for a week. In the back of my mind, I’m considering doing a 5K in two weeks, and wondered if I could run three miles. What I discovered is that I’d probably be pressed to do another mile at the pace I was running… however, if I learn to run a little slower, it should be very doable. The two miles felt good, though, so it should mostly be a matter of pacing.

In other news, I will be starting a tenure-track position in the Department of Computer Science at Allegheny College this coming academic year.

One of today’s two events has been been grossly downplayed in this blog post. Looking back at the post I has a job II, I had a great deal more to say about Olin than I’ve said here about Allegheny. I promise to rectify this shortly—Carrie and I both think this is an absolutely wonderful move, I’m excited about joining the CS department, and will be glad to be back near family. There is much more to be said, and time enough to say it in.

A few months back, I lost another hard drive. I’m tempted to think that there is something wrong either with the 160GB drives that Apple puts in their MacBooks, or that I’m doing something drastically different from my previous machine. Certainly, I can’t explain why I’d have two drive failures in under a year.

I’ll post some updates shortly; it’s been a busy, but excellent semester, and there are some good stories to tell. Perhaps. At some point.

Either way, I have a tool to post to the blog installed again, which is a big step.

Five or six weeks ago, the Estates department changed the lock on the outer door to our office suite. This was good, because our lock was mostly broken. It was bad, because we had to check keys in and out of the reception desk in the building foyer.

In the three weeks I was traveling, presenting at conferences in the name of the University of Kent, they changed that lock again. There were no keys for this lock in the reception area (that I or the member of Campus Security could find), and as a result, I was unable to get into my office today.

This was unfortunate, as I really needed to take a call from the USA in my office.

I did plan ahead; I spoke with Campus Security on Friday, and we agreed we’d get in this morning in advance of my phone call. Despite our best efforts, the Estates department won this round, and I have (most likely) missed the call I very much wanted to take. This inconvenienced many people six time zones away, and I am very sorry for that. Had I known getting into my own office would be impossible, I would have made other plans well in advance.

Ultimately, this is my fault. But sometimes, you assume you’ll be able to get into your own office, and the locks won’t have changed in the three weeks you were away.

Still note: My email addresses are in flux, and if you’re trying to reach me, use the information on the Contact page (link to left) to reach me.

Update 20070410: I spent the hour from 1PM to 2PM wondering if the timezones lineup was wrong, and wether or not I had missed the interview because of stupid things like email address and lock changes. Fortunately, my email got through, and the call went off just fine. It was good for a laugh… as really, how often do you go out doing your job, spreading the word about the work you’re doing, only to find your email address deleted and your locks changed? Usually, that requires something along the lines of a felony. In my case, it was just dumb luck.

And, yes, the email thing was partially my fault, in some convoluted way. But it still didn’t need to be deleted without warning.

If you are trying to reach me, please click the Contact link to the left, and find out how you can contact me.

As of Wednesday, my account at the University of Kent has been killed. I believe I now understand why, and it is the worst kind of “I’m just following policy” I’ve encountered in some years.

‘mcj4@kent.ac.uk’ will bounce. jadudm at gmail.com should be used for emailing me instead.

On March 29th, we gave our first Google TechTalk!

You can hit the link to go to the Google Video site. So far, we’ve had quite a few views, and apparently, people enjoy it (according to the ratings, anyway). We had a hard time targeting the talk; we rewrote it several times before giving it, as we couldn’t decide how best to approach the work we’ve been doing for the last four years. Do we dive straight into how we can use a language like occam-pi for abstracting over clusters, or how we can build safer, concurrent software on embedded platforms?

In the end, we gave an introduction to the language, and then focused a bit on how we can convert parallel models of software directly into code, and motivated this using Jon Simpson’s work with the subsumption architecture on small robotics platforms. We received many positive comments on the talk, and one person did say they thought it was light on “hard-core” detail. But what can you do in 45 minutes with an unknown audience?

In the end, we gave a good talk, and were excited to be able to share our work with the Googlers there and who are now catching the video on-line. (And, for that matter, anyone else who wants to see what we had to say.)

Certainly, it was a lot of fun. And yes, the food in the cafeterias at Google really is that good.

We spent the first three days of last week taking part in the AAAI 2007 Spring Symposium. In particular, we joined the Robotics and Education track with about 50 others interested in using robotics to teach everything from introductory programming to vision, pathfinding/planning, decision making, and all the other tasty bits of artificial intelligence.

Scribbler

Turtle

We saw some very cool projects and platforms. I really liked Roomba Pac-Man (where students program Roombas to wander hallways and vacuum up messes in a pac-man like way), and the Scribbler (while not very aesthetically pleasing) is a cute re-creation of the LOGO turtle. (I’ve provided a side-by-side comparison of what these two robots look like; the original turtle was, I think, far more attractive.)

In terms of platforms, many people are doing “tethered” robotics, where they either physically or wirelessly tether their robot to a PC. This is, I think, unfortunate, as I feel it takes something away from the process of programming the robot—it is a remote control process, as opposed to an autonomous one. However, like many things, it depends on what your pedagogic goals are. However, I do look forward to a few things: I think the Qwerk is a neat (part of the TeRK project) and we hope that we have a chance to work with it sometime in the future. It’s a powerful computational platform with a lot of nice outputs for motor and servo control, as well as managing a host of sensor inputs. Likewise, the Blackfin Handyboard is a very powerful platform, and will also be great to begin exploring, as it provides some very flexible programming options in the form of two Xilinx FPGAs. Fred and Andrew did a very nice job with the board design, and I expect many cool things will be done with this platform.

We also saw David Miller’s XBC/Gameboy combination, which I now have a Gameboy to try this out with (once I have a budget to get the rest of the bits, which is actually the expensive part). However, the really fun new platform was the Surveyor Robotics SRV-1.

Howard wrote about our experiments with the SRV-1 on his weblog, and I’ll add a bit here, and followup in a later post with some more detail. We were given an SRV-1 to borrow on Monday evening, and did very little with it, as we were missing critical software. Tuesday, during coffee breaks and the like, Christian ported the Transterpreter to the SRV-1. In less than two days, we saw a new, ARM7-based robotics platform, and had the Transterpreter running subsumption code on it. In three days (that is, the day after the conference), Christian had vision working.

I went ahead and stole a picture from Howard; here, you can see the end-result of our hacking, which is that we won the AAAI Robotics and Education robotics programming challenge. We did this with the SRV-1 after having seen it for the first time on Monday, having ported our runtime to it on Tuesday, and having seen the challenge on Wednesday morning. We managed a (not-quite-working) 3-layer subsumption network that tackled the challenge in about 20 minutes of furious hacking; I’ll write more in detail about our code (which we’ve subsequently cleaned up and corrected) in a followup post.

For now, we’re still kicking around San Francisco and the Bay area, enjoying two days off before flying back to England on Wednesday.

I’ve won an award! My housemate Poul has decided I am an excellent Ketchup Shopper!

I’m going to go find out what it is…

Goes downstairs, outside, inside, and back again…

They’re Greenfoot t-shirts! SIGCSE must be coming up…

I have a backlog of things I can write about in this space, so I’ll do my best to do a bit of catching up.

To start, Damian has been working on floating point for some time, and we now have full floating-point support in the runtime on large, little-endian targets. To be fair, the Transterpreter has always supported floating-point operations from day one. Unfortunately, it has carried out floating point operations in emulation. So, whenever the Transterpreter did floating point operations in the past, it would be emulating floating-point support and be doing all of the operations using integer maths at the interpreted level.

This was slow.

Words like molasses, glacial, and election reform come to mind as good words to describe the pace at which we used to carry out floating-point operations in the VM.

Now, due to Damian’s efforts, we have full floating-point support in the VM. This was one of the few remaining parts of the instruction set that had not been implemented yet. Now, the floating-point instructions that were introduced in later generations of the Transputer (T8 and above, I think?) are supported natively by the runtime, and we don’t have to go out for coffee every time we touch a number with a decimal point.

I previously wrote about Amazon S3 and its use for people who just need a way to cheaply/safely backup and archive content off-site. This came up at a CE-L dinner I was attending with my wife some time ago; people were discussing the relative costs of backup solutions for their work. I’ll be updating this, as JungleDisk has recently been updated with some new features that I think make it a complete no-brainer for use as a backup solution for Normal People Like Us.

In putting up a note about tools for collaborative scientific writing, I tweaked the interest of Tom Colvin over at Becoming A Writer Seriously. I’ve offered to handle more questions in this vein, as I think there is an important space here—how can you set up a writing environment that allows you to:

1. Sleep at night knowing that your working copy isn’t only on your computer,
2. Wake up in the morning and be able to revert back to a previous version,
3. Collaborate with others, anywhere, without having to worry about keeping track of which version is attached to which email, and
4. Sleep even better knowing that it is all backed up somewhere

Tom (or others) might actually have additional questions, and those will evolve through discussion on this post and others. When we’re done, hopefully Tom will have answers to his questions about using version control and straight-forward backup solutions to keep his work safer, and others will perhaps benefit from the dialogue as well.

I’ll be categorizing these posts under ‘writing’ as well as any other categories that seem relevant. That, and I’ll make a point to see that the posts are Creative Commons licensed so that others can do with them as they please.

This post is licensed under a

Creative Commons Attribution-Noncommercial-Share Alike 2.5 License.

The Transterpreter project was born three years ago around this time; it started life as a Scheme implementation of a Transputer bytecode interpreter, and has grown quite a bit since then. Given that we’re starting into 2007, it seemed like a good time to give an update about what is going on in the group. In no particular order:

• Jon Simpson (third-year undergraduate at Kent) has been working on revitalizing the LEGO Mindstorms RCX port of the Transterpreter. The old version was built on top of BrickOS; we were, effectively, running two operating systems on the LEGO, one on top of the other! Jon is at the point where he has the Transterpreter running natively on the LEGO Mindstorms RCX, can handle button input (including a nifty, non-blocking debouncer), and is continuing to slowly build up to more useful end-user interface code. By March he expects to have a complete and usable (native) port of the Transterpreter on the RCX. (/branches/new-lego)

  Looking forward, Jon (and the rest of us) are excited about getting the NXT port of the Transterpreter rolling. We have already had some interest expressed from others about taking part in this effort; we’ll be generating some mail on that shortly.

• Damian ended the year cleaning up his Cell port of the Transterpreter (/branches/cell), with particular attention being paid to developing a native, big-endian port of the Transterpreter (/branches/big-endian). Currently, we pay a penalty on all big-endian hardware, and Damian (and other’s) efforts in this regard will give us full, native performance on big-endian platforms; this effects the PowerPC (Mac, Cell) and Mindstorms RCX, among others. Looking forward, he is coming back to 42 (our experimental compiler), and wants to work out the critical points in generating little/big endian code as well as “fat binaries”.

• Adam Sampson picked up a few Arduino boards (http://www.arduino.cc/), which are driven by an Atmel ATmega8. This little chip has roughly 7KB of free flash and 1KB of RAM; it represents the smallest device the Transterpreter has been targeted at yet (/branches/arduino). While Adam’s intent was to develop an Arduino port of the Transterpreter, he says that “in the process I’ve done a load of cleanups which are probably more useful than the work I was intending to do.”

  The “cleanups” that Adam has made in the Arduino branch are (in his words):

  1. wrapper (currently untested) for the ATmega8

  2. instruction dispatching via switch, so all the instructions end up inlined, which cuts the code size considerably (and should make it a bit faster)

  3. some fixes to comments

  4. consistent ANSI C prototypes throughout

  5. add multiple-inclusion guards to all the headers

  6. make the word size code use inttypes.h and be configurable at compile
     time

  These are all nice cleanups that will ultimately be merged back into the trunk, and therefore benefit all of the Transterpreter ports.

  Adam’s explorations also involved cleaning up the “memory array” code (/branches/mem-array). When originally developing the TVM, we had a “virtual memory”, which made detecting a variety of faults easier; this was the original memory interface for the Transterpreter, but was dropped shortly after porting to C. Adam has cleaned this up as well, and (in his words, again):

  1. make the array memory backend actually work (mostly with the aim of being able to use a non-native word size, although I haven’t yet tested that)

  2. do bounds checking in mem_array so that the TVM stops (rather than
     segfaults) in the event of a bad memory access

  3. fix a number of bugs related to string handling and memory allocation which were revealed by Valgrind; we need to do a Valgrind run with some proper code (using dynamic memory) at some point to try and shake out more

  4. completely rework the code in stiw that builds the memory map, since it had a number of bugs and didn’t work with mem_array before

  5. fix a few bugs in interpreter revealed by the work above

  These are all excellent, and again will find their way back into the trunk. Indeed, as part of his explorations, Adam generated a number of tickets that I added to Trac (http://trac.transterpreter.org/), and we can begin addressing in the interpreter, which is good.

• Matt Jadud (that’s me) has been focusing on the MSP430 port, living in the Tmote Sky branch (/trunk/wrappers/tmotesky). As a side effect of this work (along with Jon Simpson), we developed ‘tinyswig’ (/trunk/scripts/tinyswig.scm), a mini, SWIG-like script that lets us quickly and easily write C extensions to the VM, callable from occam-pi. After this, we worked out the details of interacting with hardware directly from occam-pi, which (in some cases) completely eliminates the need to call out to C from occam. For example, in ‘/trunk/wrappers/tmotesky/Native‘, you can find our initial explorations in this area, where we are bringing up the virtual machine with no connections to the hardware, and then configuring the MSP430 directly from occam-pi. We expect this to make implementing functionality for new embedded platforms much easier for the developer in some cases.

  Although it is unexciting infrastructure, I also began work on migration from Autotools to Scons (/branches/scons). Currently, it is possible to build the Transterpreter for Linux/Intel, MacOSX/Intel, and the MSP430 in this branch using Scons. The build scripts are, I believe, clearer, easier to extend, and will (I believe) give us a better cross-platform build experience (eg. Windows). Currently, we have to maintain a completely separate build system for Windows, which is untenable in the long run; with Scons, we have a chance of bringing things together nicely across all major development platforms. So, while unexciting, I consider this a rather important revision of tools and infrastructure. (Of course, I’m working on it, so you might expect I’d say that.)

  Along with the under-the-radar updates to the build system, I’ve nearly finished refactoring the linker; what had grown to 5000+ lines of Scheme has been reduced to roughly 1500. While the new slinker is not done yet, it is much simpler and much more modular. The new slinker was informed greatly by our explorations with 42—the underlying data structures are far more intelligent than they used to be, and allow us to do complex things very simply. It is, in a nutshell, a joy to work with (as source code), which I can no longer say about the original slinker.

  Looking forward, I’ll be working more with two new hardware development boards for the MSP430, exploring radio communications, analog-to-digital conversion, storage of data to external devices (SD, etc.), and most importantly, the integration of interrupts with the Transterpreter scheduler. The development boards are important, as they allow me to do in-system debugging via JTAG, which will be essential for the implementation of interrupt handling. This will, like many other things we do, impact all Transterpreter ports.

• Christian Jacobsen has recently been sighted trying to set up a “build bot” for the Transterpreter project; this will automatically check out our code, build it, and run the test suite on a regular basis. However, he should not be doing this, but should be submitting the final version of his thesis. We expect that to go out the door ANY DAY NOW. I read it on my flight over to the USA, and believe-you-me, it was very, very exciting. Very.

If this sounds like we’re busy, it’s because we are. We’ve got a few other things up in the air related to our ongoing efforts, and will drop word of those as they see the light of day. If you have any questions about the project, or want to get involved, please feel free to drop me a note (matt at this domain).