Much Stuff

I know I have posted anything of substance in a few weeks now. Interests tend to wax and wane, and for me, posting to LJ has been a low priority of late. Here is a quickie summary of February:


I have only attended Ladies’ Night (Geoff’s weekly Pub Night-alternative party) twice this semester. However, I’ve entertained myself on the weekends, with movies, drinking, and so forth.

This weekend, we celebrated my friend Sarah’s 22nd birthday. A mutual friend, Matt, got very, very drunk and started reciting french love poetry. He also made me an origami flower. We helped him up to his room.

On Saturday, Fritz (), Dan, Emery, and I had a small drinking party. We told stories, listened to the latin music on XPN, and just hung out. Dan left and Joanna () came by later, and we watched The Boondock Saints. A very fun movie, in its own bizarre and gory way. Apparently they’re making a sequel.

Last weekend, Dan and I had a little movie party of our own. I sampled a wide variety of beverages. We watched the King Arthur director’s cut. There didn’t seem to be a whole lot of plot to the movie, but it seemed like a decent portrayal of England in 432 AD. I also attended the Common Rotation/TMBG concert, and went to the free Common Rotation concert on Sunday, right downstairs in New Dorm’s main lounge.

Two weekends ago was the Tau Bet Pi Spring Conference, hosted by UPenn. The Friday night social event was at the Laff House on South Street. We saw some entertaining albeit crude humor. Saturday was the business meeting and Engineering Futures sessions. That night, we watched Spanglish, and Emery made everyone Polar Bears (Godiva chocolate liqueur + créme de menthe).

Previous weekends also involved fun, although they’re already fading into the past of a semester that seems to be moving even faster than the last. I don’t know why that illusion always occurs. I guess it’s some kind of perception of time trickery.

This is making it sound like my life is chock full of what most people consider “fun”. This semester is busy, busy, busy. It doesn’t help that I have two CS requirements that I could not fulfill until this semester (Senior Conference and Theory of Computation), and on top of that, I’m being silly and taking Advanced Graphics as an elective. Bruce convinced me.


My E90 project has shifted directions somewhat. It started off as an upgrade to Mage, the low-level library that converts commands from the navigation modules on the Magellan robots to serial commands that are sent to the rFlex controller board in the bots.

ArchMage is (will be) split into three parts: the library, the module, and the simulator. Originally, the main focus was to be the simulator, which would provide false sensor data to a nav module that was linked against ArchMage instead of Mage. The point of splitting the library and the module is to have the option of running the ArchMage Simulator as a stand-alone module, or to have it just be a visualizer of data passing from the robot (where the ArchMage Module runs) to the nav module (which links against the ArchMage Library).

The other reason for the split is that we can use CMU IPC, which we already use for all of our module communication, to allow a navigation module to run on a powerful desktop PC but still communicate with the motors in the robots. This will be useful if we implement certain processor-intensive localization and mapping techniques.

I haven’t made as much progress as I would like. I’ve had to look for a job, and to work on my projects for the Advanced Graphics seminar. I definitely need to do more work over the weekends. On top of that, I’ve had a head cold that’s gotten worse over the last week, which makes my usual 8+ hour coding sessions difficult.

The other thing that will force me to reduce the capabilities of the simulator is that I need to update the teleoperation interface I used last summer. Bruce wants me to make sure that it is totally interoperable with two other E90 projects, one by Zach, Geoff, and Flurie that uses a robotic blimp, and one by Sam and Maila that uses an underwater ROV. They are writing navigation modules that are compatible with Fritz’ GCM library and Robomon module monitor, which in turns means that there is no reason why they can’t communicate with my interface.

There are a few things I need to fix. The first is to update the interface to match up with the thesis work Fritz did last semester. The biggest part of that is the Robomon capability registration. The second is to ensure that the interface will compile and run under Linux. I’m not too worried about that, since I’m using all cross-platform libraries (SDL, SDL_Image, SDL_Gfx, CMU IPC, and libxml2), but I may have a few small things I need to tweak.

The third is to ensure that my interface can handle multiple robots simultaneously. During the competition at AAAI ’04 in San Jose, I had a hack implemented that allowed me to press the spacebar and switch between two separate robot displays. I thought the original arbitrary message code would work, but there was a problem with colliding messages of the same time from different robots. I think the issue is with the way I handle messages sent to the interface. If I have time, there are a few places related to this where I can improve efficiency as well.

The last bit is to make general cosmetic improvements to the code. I’m adding Doxygen-compatible comments to all of the code, switching all of the functions from underscore to camelback format (which Bruce prefers), and renaming the module. When I started the first interface two summers ago, I called it Robobot on a silly whim when started the CVS archive. The name unfortunately stuck (although Fritz and Bruce generally just called it the Interface). This means that I need to rename it everywhere.

I have settled on calling it Rune, which stands for Robot-User Nexus. Bruce found this name hilariously geeky. In addition to being an accurate description of the functionality of the interface, it is also thematically tied to Mage and ArchMage. I’m going to go through and fix up the code with this in mind, as well as the documentation.

Lest you think that my only source of geek entertainment is coding, there is far more to go around.


Emery’s D&D campaign is going very well. I have 5 sessions of notes written up, but I have yet to post them to . If all else fails, I can catch up over Spring Break.

Dan, Fritz, and I have spent a fair amount of time the last few weeks discussing the future of computing. We’ve covered a few different ideas, all of which fall into the category of abstraction and object orientation. The short list is below.

  • Microgranularity

    Linking would occur on a function level, as opposed to library level. Obviously this would require major changes at the compiler, linker, and operating system levels. The advantages are many. If you’re doing static linking, your binary would be smaller, because only the functions you need would be included. The functions might still be grouped into “libraries”, but they would not be as monolithic as they are now.

    It would also improve package dependencies for package management systems, such as Gentoo’s portage or Debian’s apt. No longer would a single program depend on the entirety of the GNOME desktop environment when it only uses the GNOME file browser, for example.

  • Object Organization System

    Hierarchical file systems are a bad idea. They are arguably useful from an organization perspective, and they theoretically make life easier on developers and users alike by enforcing a formalism on the locations of files. However, I think there are several key ways in which they limit the potential actions of a user.

    First of all, an HFS is an abstraction on top of the hardware-level inode table. The point is, your bytes can be anywhere on disk, and files that are associated in the directory tree are not necessarily adjacent on a disk platter. This idea may be more or less relevant dependent on the storage medium.

    In the computer world, objects contain data and methods. The data may be references to other objects, or consist of associations of primitive data types. The methods define the ways in which the object’s data can be accessed and/or modified, and also the ways in which the object interacts with other objects.

    In the role of replacing a file system, objects would belong to classes that are organized in an inheritance tree that is dependent on the type of data the objects contain. In the case of, say, a document that contains text, the object’s data would be the text string, and the object’s methods would define how that string can be rendered and edited.

    Dan can probably explain this better than I can, since the idea started as a rant of his.

  • Arbitrary Metadata

    This is deeply connected with the Object Organization System, but we were discussing it particularly within the context of music files. The ID3 tagset simply sucks. It is simply not efficient to have single string fields for Genre, Artist, and so forth. I think Smart Playlists are a great idea, but because they have to rely on string matching with these fields, they are not nearly as flexible as they could be. iTunes has a decent browsing and searching interface, but on disk, everything is organized as Artist -> Album -> Song.

    Take for example the soundtrack of a Disney animated feature film. I want to in some way categorize it as being Disney. However, the album probably has the sing-a-long songs from the movie, some instrumental soundtrack music, and at least one pop version of one of the movie songs. Those categories need to be separated in some way, because the music would be so stylistically different. On top of that, for each song, you might have the characters in the movie who sang it, the performers who actually sang it (who may or may not be the characters’ voice actors), the orchestra who accompanied them, the conductor of the orchestra, the composer who wrote the score, and the lyricist who wrote the words. Obviously, this is an extreme example, but it’s hard to imagine how to organize this data in a useful way into two string fields (Artist and Composer).

    Think about this metadata in terms of an n-dimensional vector space, where n is not too big, and you can classify all of your music library in this space. You could look at clusters in the space, which represent the broad categories of your musics. You could consider the distance between individual songs. You could follow paths through the space that would minimize the “jarring” between otherwise unrelated songs. Those paths could be confined to certain clusters, or require that certain songs be included in the path. The options for usability become increasingly ridiculous, assuming that the abstraction is sufficient and that the interface is good.

    These are mostly Dan’s, Fritz’ (), and Erik’s () ideas, but I’m just writing them up for posterity. It’s fun to talk about this stuff.

  • Configuration Synchronization

    I work on a lot of different machines around campus. I want my user experience to be as consistent as possible, within reason, across all of these machines. Obviously, I can’t expect a huge amount of interface consistency between operating systems. Even between the SCCS and CS systems I have to use different window managers.

    However, I might be able to expect that my shell configuration on any *nix machine be consistent, since bash is pretty standard. I would want all of my browsers across all OSes to share the same set of bookmarks. What’s the best way to do this? Some sort of client-server synchronization? Carry around a dongle with all of my preferences on it?

    Right now, for any *nix system, including OS X, I use a CVS repository to synchronize a set of dotfiles between systems. I use a simple shell script that uses the GNU install utility to put those dotfiles where they belong. This more-or-less gets me what I want, but it basically assumes that I have the same general system configuration. My shell needs to be bash, aterm and fluxbox need to be installed, and so forth.

    What I really need is a way to define my preferences such that each system can attempt to meet my preferences to the best of its ability. This is deeply connected with the Object Organization System idea, and again would require a lot of compatibility work. I don’t even know if it’s feasible.

    I would settle for a way to synchronize my bookmarks in some arbitrary format, with converters that will run on the server end so that I pull down bookmarks appropriate for Safari, Firefox, Mozilla, IE, Opera, Camino, or whatever the heck browser I’m running.

Over the course of these discussions, we realized that these cannot be new and unique ideas. We fully accept that we’re just not that smart, and that other people have presumably thought about these issues and maybe even attempted to implement solutions. There are either problems inherent to these ideas that preclude their widespread use, or external pressures that make it not worthwhile to develop these systems.

By our estimation, Apple is the most likely candidate for doing much of this work. The open source world is too fragmented to implement such drastic sweeping change, and a single project would doubtfully be able to take on a project of such magnitude. Microsoft has little interest in innovation, as an entrenched market leader. Apple has the right creative atmosphere, a vertical monopoly from the hardware level all the way up to the application level, and a penchant for discarding backwards compatibility every few years (e.g. the floppy-diskless iMac and OS X).

Things I still need to talk about:

  • SCCS and War News Radio
  • Job hunting
  • Star Trek
  • Life outside of the Geek sphere

Nurd Up!