Carolyn Kellog of the LA Times Jacket Copy recently had this to say:

The site has a sophisticated, clean design, one which seems to assume that its members will plunge in and begin reading with little hand-holding. With its integration of social networking and magazine-style content, Fictionaut might just take off and be the next best version of Zoetrope’s Virtual Studio or NaNoWriMo.

So when’s the official launch date? Well, we’re still watching the way the community works — if everything is running smoothly then it shouldn’t be too much longer.

I borrowed Samuel Bravo Silva’s excellent “cylinder_tree” sketch and ported it to my native GL framework (called CBGameworks, soon to be released). Download Octopus.zip (51KB) (seen above). Keys ESDF move the camera. R peds upward. L toggles lighting, off by default.

Source code (73KB) is available for download, bundled with an undocumented and symbol-stripped version of my CBGameworks library.

It’s truly amazing what Ben Fry’s little framework has done to the demo scene in the past two years. Despite having made no real technical achievement, Processing has become the de-facto engine for interactive art — exhibiting itself in galleries, on magazine covers, and all over the internet. Its success lies in its simplicity, its elegance — the shared value among artists and programmers that connects both sides of the brain. And while it’s true that more powerful tools are available, nothing else comes with such a clear methodology, extensible design, and fanatical community.

Check out the processing group on Vimeo. Stunning. The top two producers, in my opinion, are Marius Watz (watz) and Robert Hodgin (flight404) of The Barbarian Group.

This is tremendously cool and very thoughtful of Radiohead to copyleft this part of their work.

Unfortunately Google or Radiohead has only provided a one minute sample of the animation data, which isn’t much to work with. Of the 14,000 data downloads and counting, I think this probably explains why no one has come up with anything too striking on the YouTube Remix Group.

Still, I grabbed the data and got to work. First step: better tools. Personally I feel the Processing code is just too slow and painful to work with. OpenGL really needs to be run through native code.

So the first app I wrote is a Obj-C based first-person browser of the city street landscape (which includes 1.3 million vertices). It’s intel Mac-only and completely untested, but if you’re daring it might be fun to play with. It takes a couple seconds to load all the points, but then runs surprisingly fast. I get 30fps on my first-generation MacBook Pro.

You can download it here (21.6MB):
http://files.carsonbaker.org/hoc/HOC-CitySceneViewer.zip

Or watch a quick demonstration on YouTube.

Two more apps are on their way. One just displays the other landscape; the other is a facial animation viewer of Thom. These projects are layered on top of a custom OpenGL threaded graphics framework I built four years ago — just something that comes in handy from time to time. In a way it has kind of evolved into its own mini-version of Processing, without the performance penalties.

So, what about source code? Well, if Radiohead releases the entire data set then I’ll post sources for everything, including my graphics framework and the client code. I don’t know how hard it is to prepare the data, but I don’t think that’s too unreasonable of an idea. I think it’s win-win — more people could put together better montages with a more capable tool.

If Google decides to release more of the data, one thing I suggested is not distributing the vertex points as CSV data. It makes it much bigger to download and slower to parse. Why CSV anyway? Hopefully people aren’t opening this stuff up in Excel. Save it as binary! We can handle it. Here’s some code to do it:

http://files.carsonbaker.org/hoc/csv_to_binary.c.txt

Also — for anyone that might know:

It’s not clear to me how the Geometric Informatics capture hardware works. What’s the technology behind it? How much does their GeoVideo system cost? I’m having a hard time finding this out.

Watch the above video in high-definition on Vimeo.

Source code is available (1.5MB):
http://carsonbaker.org/wp-content/uploads/2008/07/thom.zip

The point data set is not included. Download it from the Google project site.

So for anyone that needs to access their Time Machine from something other than its associated Mac, here’s how you do it:

Mount the drive. On linux it should automount if you have gnome-volume-manager installed. If you don’t see it in /media then run nautilus and check the desktop. Still don’t see it? Read man mount. And then don’t forget the -t hfsplus flag.

Change directory. My mount point is /media/Time Machine/. Within that path I find the directory Backups.backupdb/. This represents the directory layout of your backup system. Inside that directory is the name of your disk. Inside that are folders labeled with dates corresponding to each incremental backup that was made. Pick the one you want, or choose the Latest symlink. For example, my path is now:

/media/Time Machine/Backups.backupdb/Drive\ 1/2008-06-05-073745

Find your file’s folder. Within that path is a complete representation of your filesystem. Navigate to the location of your file. If it’s not too big or nested too deep, it may be plainly visible. However there’s a good chance that its parent directory doesn’t exist. Instead you’ll see a zero-byte file for the parent that takes its name and acts as a pointer. Run ls -l and take note of the first numbered column. Example:

...
-r--r--r-- 2155704 root 5791966       0 2007-06-25 02:54 Wallpaper
-r--r--r-- 2155725 root 5791967       0 2007-06-25 02:54 Web-Identity
-r--r--r-- 5441953 root 5791968       0 2007-06-25 02:54 Windows
-r--r--r-- 5511926 root 5791969       0 2007-06-25 02:54 Work

After the permissions you’ll see the directory number that typically refers to the number of directories within that folder. For a file it should always be 1. Here it is not. What Apple has done is adjust the information in this file’s inode to use it as a pointer to the directory that contains the actual file. That way multiple revisions of the same drive can coexist without duplicating data.

Find the data. So in my case I want to grab something out of the Wallpaper folder. First I make a note of the directory number, 2155704 and then cd /media/Time Machine/.HFS+ Private Directory Data. This is where the data really lives. From there just cd dir_2155704 and voilà!

I did, however, find a good overview of the subject by Mad Teddy. [Explore his website to discover why he is, in fact, quite mad.]

Ten minutes later I generated my own biomorph:

Download the source code as an Xcode project (Mac only, 51 KB). Possible improvements, including animations, to follow.

Unless you’re working for NASA, you probably don’t have to prove your invariants—so stop pretending. If you understand the problem you’re approaching, and you’re competent enough, you’ll quickly figure out a reasonable way to get there. Even if you make mistakes along the way, who wants to bet it’s easier to correct them after the fact, when everything is set out plain and clear than it is to try to nail the solution the first time around. Think about the tradeoff you make everytime you draw a UML diagram. Is your careful planning really saving development time? No, you’re massaging yourself into delusion—your model isn’t robust; you’ve ignored the implementation details; and now you have to manage another component of the system.

Let’s think about the evolution of software design over the past decade and try to draw out a few points. In the beginning there was assembly, of which the function call pattern was a design issue. C made it obsolete—you had to use it. Then the theorists spent their time lecturing on the OO paradigm, writing books, and generally coercing the masses into its adoption. C++ obsoleted that. Since then, further refinements in the way we program have transpired, giving rise to Java, C#, and agile techniques. So at least for the moment, the issue of design has been resolved. Given the hardware we currently use it seems unlikely that there will be any new paradigm shifts. Oh no. What are the authors, the theorists, and the managers to do?

Here’s a challenge: find all the software design books of the past few years and look up the author’s biographies. How many still regularly program? It should be surprising, except when you realize that there’s a lot more money in consulting than in actual programming. I’d say most of the “top ten” advice you get when you read about software engineering should be taken about as seriously as your horoscope.

Yet although they’re obnoxious, I don’t see the designarati as the reason people fall into the pit. To me software development is an art. It requires practice and learning by example, also by doing. And it’s a subjective thing; what works for you may not work for someone else. The important thing is think a little about what makes sense and then get to work. You can’t preemptively design your way to a solution. It’s a premature optimization of the very worst temptation.

The result is that I see a not insignificant amount of traffic to this website. This is great; having a website that many people visit challenges me to create interesting things. (Whether or not anyone cares about it is another matter.) My challenge now is to think of the genre that I want to write about, and the types of things people will read. Those who stumble upon this page are almost certainly of the techno-culture crowd, so my immediate vector is in that direction.

What I will not do is relate personal stories, comment on memes, or throw my voice into any discussion that is already too big. My intent is to make this weblog worthwhile to everyone who reads it—not just for friends or family, and not just for those who care only about something specific or obscure.

I’ve never really had a personal weblog before, so I guess we’ll see how it goes. Hopefully the fresh redesign and transition to Wordpress will be a catalyst to keep me on top of things. In summary, my rules:

• Stay fresh.
• No journaling, no meming.
• Be original. Be useful.

Many thanks to those that visit.

There are many packages for PC, some of them free, many of them commercial. The commercial variety can cost anywhere from $100 - $5000 dollars, depending on how gullible you are. I used the free and trial versions of MPLAB, the IDE that Microchip distributes, in conjunction with HiTech’s PICC Lite.

I began by installing the software that came with my PicKit into Virtual PC and working with the IDE there. As anyone who has actually tried using Virtual PC for any serious work will tell you, it’s very frustrating. I had to jump through a bunch of hoops and set up a few hacks to let me even compile what I needed. Then I would transfer the binary to Mac OS X and use usb_pickit to get the binary into the hardware. It was a slow, tedious process but it worked—which is important.

The second thing I tried was assembly. GNUPic has a package that contains an assembler, disassembler, profiler, and an interesting high-level language called gpal. Unfortunately, various parts of this collection only work with certain PIC models. I learned the asm codes from the datasheet (it wasn’t too hard) and proceeded to write code. I soon learned that complex math should not be attempted in asm. Flow-control was easy enough but beyond simple addition and subtraction, anything like sin(1.5) / 5.3 + 9^3 is heavily obfuscated. Yet this too worked.

GPAL, it seems, is not ready for prime-time. There is very little example code and sparse documentation. If I have some time though, I’ll plow on and see if I can figure things out and perhaps build a repository of code that others can use.

The things that didn’t work? Take a look. Half of these links are dead or broken and the other half lead to incomplete projects. SDCC looks to be the most promising. This isn’t saying much, and I only think that it’s being updated semi-regularly.

Lessons learned? Try Atmel and AVR-GCC. Also, some serious thought should be given to the idea that ANSI C probably isn’t the best language from which to compile code for a MCU that can’t do recursion or even floating-point arithmetic.

enum Face {ACE=1, TWO, THREE, ... , QUEEN, KING};

If you want to step through this datatype you can’t just do:

Face f; f++;

No, you must do some kind of conditional checking or integer-to-enum casting which becomes unsightly and difficult. Instead, simply overload the ++ operator for the enum type:

Face operator++(Face& f, int) { // int denotes postfix++
    if (f == KING) return f = ACE; //rollover
    int temp = f;
    return f = static_cast<face> (++temp);
}

Now f++ works properly and you can enumerate away.