• Vote on Oct 14!

  

• Search for:
• 
  This work is licensed under a Creative Commons Attribution 2.5 Canada License.

• Similar Posts

  • IMS LOM Proposal: Multiple Technical Elements to Support Thumbnails etc…
  • Help Wanted
  • Working on XStreamDB WebObjects EOAdaptor
  • Migrating from WordPress to Drupal?
  • Killing MT Spam Dead

• Pages

  • About
    • Bookshelf
    • Colophon
    • Contact
    • Music
    • My (not so) Secret Identities
    • Presentations
  • Archives
  • Asides
  • Photos
  • WordPress
    • Post Revision Display

• My Other Places

  • Mindfulseeing.com (photoblog)
  • Flickr/dnorman
  • Teaching & Learning Centre
  • The University of Calgary

• Recent Comments

  • dnorman on RIP Structured Blogging and Microformats?
  • Chris L on RIP Structured Blogging and Microformats?
  • WP插件推荐 10/08 | 韶华白首 on Post Revision Display
  • Susan on WordPress Plugin - Post Revision Display
  • WordPress Plugin Releases for 10/08 | Wordpress Blog NL on Post Revision Display

• Meta

  • Log in
  • Entries RSS
  • Comments RSS
  • WordPress.org

I’m a big fan of the concept of “code smells” - the notion that you can subconsciously evaluate the elegance/correctness of a code by how it “smells” to you. Similar to “beauty” in mathematics or physics, I suppose.

Sean Corfield, at An Architect’s View, just posted an overview of Josh Kerievsky’s session at SD West.

For example, when touring the Pachyderm codebase, you can tell who wrote it by the smell. King’s code smells like a tropical beach. Clean. Breezy. A place you want to spend the day hanging out.

My code, on the other hand, tends more toward a downtown back alley - functional, not the cleanest place to be, not someplace you want to spend a lot of time, and often smelling oddly of fish.

I’ve been making some time to think seriously about some of the assumptions and preconceptions I have regarding metadata, in light of my quick and dirty asset management tool.

I had committed 100% to the “rich, deep metadata is beautiful” mantra, drinking the IMS/IEEE LOM Kool-Aid™. I’ve built Large Applications that have been designed entirely around handling the complexity of this rich/deep metadata, and trying to abstract that enough to let me build actual functionality on top of it.

My epiphany over the weekend is that this approach is rather flawed. As King has been saying for almost 2 years now - the asset/learning object is the centre of things - not the metadata. And certainly not the rich/deep metadata specification.

I’m taking the opportunity to think critically about some of the projects I’ve done over the last few years, and am realizing just how simple many of them would be if I’d tossed the rich/deep metadata baggage long ago. For instance, the Teaching Resources collection was deployed as a test application, contrived to evaluate an XML database. It could have been built on top of a simple Dublin Core (or less) database, in maybe a couple dozen lines of PHP. I’ll be rebuilding it this way (on top of my Dublin Core compliant asset manager) when I get a chance, and it will make it much easier to add new items, or to edit existing ones.

Thanks also to Scott Wilson, who just posted an entry "In Praise of Simpler Standards?" that nicely sums up some of the logic behind both ends of the metadata complexity spectrum.

I’ve just worked up a drop-dead simple asset metadata database for the Pachyderm project. It’s just a MySQL database, with a single table that has 10 fields (including primary key). This simple database will serve basic metadata needs for the Pachyderm beta.

I also built a simple asset management system to test out the database. I decided to do a lightweight PHP “application” to stretch my legs in a non-WebObjects non-Java environment. This is about as far from the elegant Model View Controller design pattern as it gets. Raw SQL is littered throughout the PHP code. But, you know what? It works. And is unbelievably simple to debug.

I’m thinking a version of this PHP asset management app, running on top of a simple asset metadata database, may form a valuable Small Piece, patterned after del.icio.us, but giving us the ability to extend for our purposes.

My previous thinking about metadata storage was stuck in the conventional “hardened”, enterprise-class thinking that only storing an IEEE LOM would satisfy. Bollocks. This simple metadata database will gladly be coerced to spit out IEEE LOM records on demand, or Dublin Core, or whatever else is required.

There’s a meme going around that says something like “the best solution is the absolute simplest thing that could possibly work” (I’ve heard it in a couple ITConversations sessions, and on a couple blogs - I’ll have to track down who started it…) This solution is in that vein, and it’s really striking a cord with me.

Give it a shot, if you like. But, be gentle, since it’s my first real PHP work, and was cobbled together with the help of my on-demand guidance system. (oh, and I know it looks like crap - I haven’t even started thinking about UI for it)

UPDATE: I’ve been slowly working on the asset manager test app when I get the chance. It strikes me just how simple it is to build. With the use of includes, it should be entirely possible to approach nice OOP design, although it won’t be all MVC. But, if it’s this simple to do, maybe you don’t need MVC… I added file upload and MIME type recording in maybe 15 minutes, including the google-time to figure out what to do. I’m really enjoying PHP as a language - having some flashbacks to Lingo. The power of small pieces…

UPDATE: As I’m adding/tweaking stuff in this simple asset manager, I’ve realized that it is probably only a week or 2 of effort away from replicating the functionality of CAREO. I could use simple stylesheet switching to replace the “themes” in CAREO. All that is really left to add is authentication, activity tracking, RSS views, and a few other types of queries. But, as a few simple PHP scripts (currently maybe a total of 100 lines of code spread over a handful of files) instead of large java frameworks and applications, it should be much easier for others to extend and adapt for their needs… I do realize that my current attempt at PHP code is rather inelegant, but I’m hoping to follow some of the patterns and techniques used in WordPress to keep it clean, modular, and extensible.

Yet Another UPDATE: I’ve updated the asset database to store the full Dublin Core set of elements, so it should serve as a pretty solid foundation for any asset management use… I’ll try porting the Teaching Resources Database over to it to see how it goes… Using an XML database is overkill for that anyway, and if I use the asset manager, I get to throw in the add/edit functionality for free (something that’s on my plate for Teaching Resources anyway, so if I can just re-use this code, I’m further ahead already).

An interesting idea… Web technologies: a first step towards biomimetism? The idea that enterprise-class, “hardened” applications are flawed by nature, and that web technologies that mimic biology in the ability to adapt and respond are more successful and appropriate.

It’s another telling of the small pieces loosely joined story. One that’s been going through my head very loudly lately (as it has before).

Things like the new Technorati Tags system really showcase what can be done with the loosely bound small pieces, rather than trying to build the entire widget (or series of widgets, or framework of widgets) yourself.

Over the next year, I plan on investigating this much more closely as it pertains to blended learning. What are the small pieces? How can they be tied together? What is the larger ecology that forms as the pieces learn about each other? Where are the gaps and opportunities?

I’m definitely not alone in my interest in this model. James Farmer is thinking about it too… (as are Alan, Brian, and many others…)

Josh and I (and sometimes King) have been utilizing a pair-programming-at-a-distance method of collaboration (not quite like spooky action at a distance, but sometimes it feels pretty close…)

Our magic sweet spot combo of tools includes 2 computers at each end of the pipe, one with VNC (a server at one end, a client at the other), and the other computer acting as “support”, with iChatAV acting as our communications bridge, and various browsers and utilities handy on the non-shared screen. We leave an iChat video connection open, so we can communicate without having to stop editing source code to enter chat mode. This rocks nicely.

We had been using plain audio before, but Josh just got his iSight camera, so the open video line adds another dimension (and even without the video, the audio is much better - without needing headphones to kill the feedback loop). It could also come in handy, since he has a large whiteboard behind his chair, so he can sketch things up on it and I can see what he’s drawing.

I never thought I’d be a such a fan of distance collaboration (although it has worked extremely well before) - it is always better to meet in person. But this combo makes it about as close to a face-to-face meeting as possible. Still not quite there, but pretty darned close.

One of the cooler things about the setup is that, except for the iSight cameras (which are entirely optional, but sure work nicely), the entire setup uses free software. Not necessarily Free Software, but no expense. This blows the doors off of Breeze Live, Centra, and any number of other “collaboration” suites.

We’re seriously thinking of writing a paper, and/or presenting something at the next NMC conference on this setup.

I’ve been reading through the wiki pages for Brian Lamb’s presentation on wikis etc. at David Wiley’s recent ITI conference. Excellent excellent reading. Brian has done an awesome job as usual in gathering supporting resources. Man, if I could just borrow his brain for a while, I’d have my Master’s thesis done (but that’s another story).

Anyway, Brian linked to a post by Jon Udell: Collaborative Knowledge Gardening - basically on how the role of metadata is effectively shifting, and less formally described strategies are showing the promise of being more effective. He compares tools like Flickr.com, which uses “bags of keywords” to the more conventional strategies of complex taxonomies.

I’ve become a huge fan of Flickr, and have to admit that using it has really opened my eyes to the power and flexibility of the “bags of keywords” approach. Just look at the “Favorite Tags” page on Flickr - these are keywords that people have voluntarily added to their photo uploads, and they’ve been found by other users. That sounds like a controlled vocabulary, without the centralized control… It’s also quite cool to be able to enter any tag you want and (usually) find some matching photos. You don’t have to browse a predefined vocabulary, you can just use your own…

I really think that strategies that enable both centralized top-down as well as decentralized bottom-up approaches will be the most successful (easy for The People to use, easy for The Institution to adopt).

Adam Bosworth has a good post on architecture/design and the KISS principle (thanks to Tim Bray for the pointer). I have to reflect that the most successful software I’ve been involved with has followed this, and the least successful has not. Coincidence? Possibly. I think there’s more to it than that, though…

KISS has lots of deep ramifications. Simple systems are easier to build. There is less to maintain. Less pieces to go wrong. It’s also easier for other folks to jump in and play - they don’t have to learn a whole new universe to get started, they just go.

Actually, APOLLO is able to work on both sides of the spectrum - some rather complex bits, based on a rather simple overall architecture, providing ways for developers to easily build simple apps…