view printer-friendly version (opens in new window)
LOM/CanCore Open-Source Software Components released
Rather than building a complete metadata application that only meets one set of current needs, the CanCore people built a set of components that can be re-used in many digital library applications that suit your requirements. It's an approach to open source educational software development that we're going to hear much more about.
At first flush, it probably seems much more satisfying to deliver one complete, turnkey tool. Just plonk it on a machine, and after a nice splashscreen with your own logo, that is it: it works. Except that the people in institution Y need another doohickey that your app doesn't have. And the people in institution Z want your app to talk to some system you've never heard of. And the users in your own institution would like another user interface, etc. and so on.
Some tools are built flexibly to accommodate such modification (e.g. Reload), many more are essentially monolithic and would require a close-to-make-no-difference re-write to do anything other than what it was originally intended for.
This effect is particularly strongly felt in educational open source software, which is typically built by one team on a project grant, and then left to its own devices. The idea is that others will pick up the project, and further refine it. In practice, however, the work involved in adapting an existing monolithic application is so large that you might as well start again.
The answer, then, is to build a component or service based architecture, which is exactly what the CanCore people did. The three components they just released -a programmatic handle (API) on metadata records, a metadata repository API and an LDAP based LOM repository- are essentially building blocks for whatever digital library you want. Though the team did built basic ready-to-use implementations of all these components, the idea is that other developers can save weeks, or even months, of development time by dropping the components into the programs that they are building.
The CanCore LOM Java binding (which provides a programming handle on metadata records) is a particularly good example of the approach. For an application to manipulate a LOM type metadata record, it needs to have some understanding of the structure of that record. You could try to code that straight into your own application, in such a way that any function you need could more or less directly edit the relevant node in the record. Which is fine, but not very flexible and rather laborious. The CanCore LOM Java binding essentially does that for you, without making any presumptions about what you want to manipulate in the LOM record, or how. Provided your application is also written in Java, of course. Fortunately, rather a lot are.
The CanCore Learning Object Repository (LOR) Java interface is already a little less abstract, and makes it possible to expose LOM records and their data in a networked environment. It's the core of a repository, without all the functions and user interfaces that make it useable. The reference implementation that is also provided should go a long way towards that goal, and also provides a basic web service implementation. With one of those, even less is presumed of the rest of the Managed Learning Environment (MLE) that a repository will work in- as long as the rest of that MLE has some notion of IMS Digital Repository Interoperability.
The CanCore LOR - LDAP (Lightweight Directory Access Protocol; a very widely used network access protocol) implementation, is essentially a more specific application of the LOR interface, with an added LOM specific LDAP scheme. It's essentially a cheap and cheerful digital repository that's very easy to implement.
The trick of all of these components is that they need to be pitched at the right level of abstraction: too abstract, and there's too much work involved in getting it to do useful stuff, too specific, and there's too much work involved in getting it to do what it needs to do. The CanCore LOM components offer the choice: if you need maximum flexibility, use the Java binding, if you want something that 'just works', use the LOR-LDAP implementation.
At any rate, the more people build components like these, the better, cheaper, and faster it will be to build educational open source software for specific purposes.
The CanCore Components can be downloaded from the CanCore website. They are fully documented using Java Doc, have LGPL licenses (which means they can be linked to by non-free programmes) and are designed to work with Java 1.4 run time environments on your favourite operating system.