Reasons Why

Less is More

Adaptive hypermedia, graphs, and other animals

I'm new to kuro5hin, but as a newbie researcher in the field of web-based learning, I just couldn't resist a few comments. Kudos to the poster for bringing up this subject.

Now for some summing-up: You are proposing to re-do WebCT (or Blackboard, or TopClass) in an open-source fashion, and with multiple collaborating authors that submit peer-reviewed material to the course. A second interesting idea is to keep well-groomed "defining assumptions" for each module. This boils down to two issues: collaborative course authoring, and metadata on the nodes.

I would like to add something from my field of experience: adaptive hypermedia. The idea is to present a user only "relevant" parts of the course, by taking into account his "profile". Where the profile is both static (ie: what have you studied) and dynamic (what modules have you visited/liked/scored poorly). Plainly stated: get the course adapted to the student, and not the other way around. You can adapt it two ways: change the contents, or change the structure (as in suggest/disencourage hyperlinks). We do mainly the latter. No big deal?

It turns out that this /is/ a big deal, because of a few factors:

When the number of alternative paths gets high, and the complexity of the decision rules (ie.: what paths are recommended over others for a given profile) increases, the structure becomes a nightmare to author.

When the number of modules grows large, it is very hard to ensure that all paths leading to each path makes sense.

And finally, when updating contents, maintaining different versions of modules that are linked from different places with different requirements is not an easy task (similar to DLL hell).

I have recently finished a project that suggests using a graph instead of a tree to lessen problems #1 and #2. The big problem with graphs, as one comment stated, is that they tend to be much more difficult to create and manipulate than trees - allthough a few techniques do help out. If anybody has time to burn, check out the pdf (comments would be very apreciated). In my view, knowledge is a web much more than it is a tree - and as one poster put it, you need one hell of an editor when you edit something this complex.

Other features we are trying to add to our homegrown (and soon-to-be-GPLed) adaptive course system include collaborative tasks. The problem with motivation (as noted by a few posters) is very real: if you sit alone in front of your screen, clicking "next lesson" (*must avoid Simpson quote*) every now and then, you had better bring all the motivation you can muster. If you can get students to work with each other solving tasks, or simply see who's on the same problem and ask/offer help, courses would be less passive. Getting lessons that are actually interesting (adaptivity!) helps here, too.

As several posters have written, there are multiple efforts underway to standarize metadata-annotated content into "learning objects". SCORM (linked here) is a good source for more info. Most of these schemes use some kind of semantic markup (RDF or some apropos-XML) to make dependencies machine-parseable. But the topic of knowledge management and reuse is still far from solved - even with well annotated contents, you have to ensure that authors can find what they need and seamlessly adapt it into their courses.

Another challenge is what to do when everybody can contribute to the knowledge pool, and there are no pre-defined courses. You then need some kind of planning system that given a "learning goal" and the student's previous experience and/or actions, searches in the knowledge pool and arranges relevant modules into a well-knit sequence (or a series of alternative paths). Re-planning would be necessary if the student chooses to go for another route. An alternative is simply not to plan, simply keep an eye on the student and hint what the next "logical" step may be (or where to go to get more background or such).

One final comment: if the system is really large, server-side scripts such as PHP will probably not cut it. If modularity and maintainance is needed, something more structured, such as Java, may come in handy.

Ahem, I think this will be enough preaching for the day. Please don't flame my previous paragraph too much.