WWDC 2004 Coverage

Looks like there may not be a satellite feed for the Stevenote this year. Failing that, there’s the O’Reilly coverage, as noted on their MacDevCenter…

O’Reilly at WWDC 2004 by Derrick Story — The Mac crew at O’Reilly has lots going on at this year’s WWDC. If you’re attending the ultimate Mac bash in San Francisco, then you might want to make a mental note about the following O’Reilly-related offerings, including book specials, O’Reilly-hosted BoFs, and our ongoing conference coverage.

XML via EOF Redux

Before leaving for the NMC 2004 Summer Conference, I handed King the code I’d hacked together to implement XML KeyValueCoding and the XStreamDB EOAdaptor. He needed the XML KVC part to implement an ECL client in APOLLO, so it should have worked just fine.

In usual King form, he went through my code, and when he was done, it looked like part of the EOF stack itself – all of the niggly loose ends I was struggling with were properly cauterized – no, that’s too rough – they were reworked with Best Practices and EOF methodology so they worked properly, rather than just working (yes, there is a distinction 😉 ).

Anyway, I’m working on re-integrating King’s wonderful code cleanup into the working XStreamDB EOAdaptor. It’s already promising to be much faster due to the proper implementation of KVC caching (rather than looking up values each and every time from the DOM, it stores them in a lazy-bound way, so it’s only looked up the “hard way” the first time, and after changes).

Once the changes are merged back in (shouldn’t take too long – the biggest task is deciding to use XStreamDB 3.0c or 3.1 client libraries), it should be a well oiled and almost fully functioning XStreamDB query engine. Then, to work on editing and adding records…

Anyway, I just wanted to give some quasi-public kudos to King. I’m constantly amazed at the amount of actual working stuff he’s got crammed in his skull.

21 Rules of Thumb – How Microsoft Develops Its Software

I’m sure this is going to be linked all over the place, but it’s a very interesting read. It’s a reposting by David Gristwood, of an original article by Jim McCarthy (a manager on the MS Visual C++ team).

Particularly interesting and useful, it delves into the topic of “slippage”, but treats it as a necessary and good part of the process. Slippage becomes a transition from the unknown to the less unknown – as you know more, the timeline and estimates become more refined and realistic, often leading to slippage.

Perhaps the most important point is the first one: Don’t know what you don’t know. If you don’t know something, state that, and come up with a plan to fill the gap. Incorrectly assuming knowledge, or worse – faking it – will lead to disaster.

UPDATE: Just came across a link to The Ten Commandments of Egoless Programming – more good stuff. Even comes with a handy downloadable (if butt ugly) stone tablet for printing.

I think I’ve been risking breaking Commandment #9: Don’t be “the guy in the room” – going to have to work harder to prevent that. 🙁

Learning Object Projects at the Learning Commons

We’re working on a whole bunch of related (and sometimes dependent) projects here at the Learning Commons, and it’s sometimes difficult to communicate how they all fit together.

Although we are coming at several related problems from several directions simultaneously, we see them all as One Big Project, with each component making up part of a larger puzzle. Here’s the extremely simplified model of how the projects fit together:

Project Puzzle Pieces

Perhaps the easiest way of thinking about these projects is with APOLLO acting as a kind of malleable glue that can hold distinct and separate technologies together. We see things like ties to Blackboard LMS happening somehow via APOLLO, which can serve as a bridge between any of the other project puzzle pieces.

One important thing we keep striving toward is interoperability. Interoperability amongst our own tools (ALOHA, APOLLO, CAREO, etc…), and interoperability amongst external tools (Blackboard, Pachyderm, Weblogs, etc..). They are both important kinds of interoperability, and we take it all quite seriously.

It’s also feeling like we’re in the process of hitting critical mass, where the project puzzle pieces are finally fitting together well enough, and covering enough of the whole puzzle, that we’ll be able to do some extremely cool and compelling things in the coming weeks and months. This is an excellent time to be playing around with this stuff.

Here’s a partial list of some of the related projects we’re working on at the Learning Commons:

There are several other smaller projects (and possibly some larger ones) I’ve left off, but you get the point. We’re trying out a bunch of stuff, and working to get it all playing nicely together.