skip to main page content CETIS: Click here to return to the homepage
the centre for educational technology interoperability standards

skip over the long navigation bar
Press centre

Inside Cetis
what is Cetis?
Contact us
Cetis staff
Jobs at CETIS


XML: Click here to get the news as an RSS XML file XML: Click here to get the news as an Atom XML file iCAL: Click here to get the events as an iCalendar file

what are learning technology standards?
who's involved?
who's doing what?

CETIS Groups
what are cetis groups?
what difference can they make?
Assessment SIG
Educational Content SIG
Enterprise SIG
Metadata SIG
Life Long Learning Group
Portfolio SIG
Accessibility Group
Pedagogy Forum
Developer's forum

Accessibility (310)
Assessment (74)
Content (283)
Metadata (195)
Pedagogy (34)
Profile (138)
Tools (197)
For Developers (569)
For Educators (344)
For Managers (339)
For Members (584)
SCORM (118)
AICC (18)
CEN (34)
DCMI (36)
EML (47)
IEEE (79)
IMS (302)
ISO (21)
OAI (24)
OKI (20)
W3C (37)

print this article (opens in new window) view printer-friendly version (opens in new window)

CopperCore to power Learning Design implementations

image:CopperCore to power Learning Design implementations

The Open University of the Netherlands (OUNL) has just released CopperCore: an IMS Learning Design engine, the first of its kind. Rather than provide a complete take-it-or-leave-it Virtual Learning Environment (VLE), the open source package is designed to be integrated into a range of existing e-learning infrastructures.

From a pedagogical point of view, the EU Alfanet project sponsored CopperCore engine functions more or less like an invisible online classroom assistant. In a conventional learning activity, an educator would draw up a lesson plan, with different activities in small groups, whole class or individually, using textbooks, handouts or the white board, including tasks like debating a supposition, doing a test or collaborating on an essay. Having someone around to make sure that all the resources are there and that the class is divided into the right groups at the right time and doing the planned activity is rather handy.

IMS learning design allows an educator to capture such a learning scenario in a standardised machine readable format- bearing in mind that there are a lot of things possible online that you can't easily do face to face. Like a classroom assistant, CopperCore can take the educator's Learning Design, read it, make sure that all the necessary resources are there, the class divided in groups at the right time, and presented with the right activity. It can also, crucially, keep track of the activities and coordinate between the tools that are used in the learning scenario. Everything but actually teach, basically.

What it also cannot do (well) is provide the visible tools that learners and educators would work with. There is a basic web interface that shows what CopperCore can do, but that's emphatically not the point. Like a lot of modern software, CopperCore is component based. The idea is that, rather than duplicate functions that are already done very nicely elsewhere, an application should focus on doing its own thing well, and make sure it plays nice with all the others.

For CopperCore, that means that it is not trying to be another VLE, but makes it possible for existing VLEs, and colloborative software such as chat, email and online fora to play their part in a structured learning activity. Ideally, then, learners and educators would mostly interact with software they already know (plus a few simple and innovative new ones), but in learning activities that are vastly richer than what is possible with most tools today.

The gubbins

At present, CopperCore communicates with those other tools via Java enterprise beans- a common component standard for the J2EE platform. Perhaps more intruiging is the fact that it would, according to CopperCore developer Hubert Vogtens, be fairly easy to have the beans talk SOAP- a widely used cross-platform webservices messaging format that is shaping up to become a standard in e-learning as well. The advantage of SOAP is that the basic messaging infrastructure is well known, widely implemented and that it fits in with a number of other webservices specifications. It is also relatively easy to implement; Hubert points out that some Java tools let you automatically build a SOAP interface from Java Beans. The CopperCore team is evaluating whether a SOAP interface should be part of the standard distribution of CopperCore.

Once implemented as a web service, it should be easy to make learning activities genuinely distributed. That is, one CopperCore engine, reading one Learning Design should be able to coordinate whatever tools are in a learner's environment, wherever they are. Provided, of course, that the tools have the ability to understand Learning Design specific commands, and are capable of giving the right notifications back to CopperCore.

That would require some work. Though CopperCore handles most of the integration, computation, state and data storage, CopperCore enabled tools will still have to know about such things as particular role to participant mappings, or how to end a particular activity.

The specific functions that CopperCore provides to help third party tools are a CourseManager Application Program Interface (API), a Timer API and the LDengine API. The Coursemanager looks after users, roles and publications, the Timer after various time based triggers. The real deal is the LDEngine: that provides run-time behaviour such as maintaining the states of activities and the environment, and completions of same. There's also a library to validate Learning Design XML.

Delving further into the gubbins, the software that provides these APIs is notably heavy duty. Storage has been tested on PostgreSQL and MS SQL Server 2000 (though any relational database will do), the persistence and business logic are encapsulated in Enterprise Java Beans. This means that CopperCore can be deployed on any J2EE application server, on most any platform.

The OUNL has not released CopperCore as just a boost to the IMS Learning Design specification that it helped design. It is already used and operational in a pilot of the Alfanet environment, where it is integrated with other tools. One of these is .LRN: an enterprise class course management and collaboration framework from MIT Sloan and Universitšt Heidelberg. This is built on OpenACS, which is built on, arguably, the most powerful webserver there is: AOLserver. Clearly, Alfanet is building the whole stack to handle lots and lots of concurrent hits. According to Hubert Vogtens, the OUNL is also evaluating other systems for use in its own learning networks environment.


If one were to ask many an e-learning technologist what the most ideal modern e-learning software would look like conceptually, they'd describe something very much like CopperCore. The pedagogic richness of Learning Design, standard compliant and open source, the flexibility and adaptability of a component architecture, and easily webservices enabled to boot. All on a solid, proven technological basis. Just take it, and integrate it into whatever you've got already, in a way that suits your needs.

That also means that expectations could easily reach quite giddy heights. As with any new project on this scale, however, a number of question marks remain. Chief of these is the question whether enough good quality, CopperCore enabled tools can be built and made to cooperate properly, or how many existing VLEs can integrate CopperCore successfully. Without them, the package will remain next to useless for educators.

Other questions include such things as whether enough Learning Design authoring tools will become available (though the Reload authoring tool is scheduled to include Learning Design authoring capability shortly), and the question how Learning Designs can be shared between two CopperCore enabled sites with very different e-learning infrastructures: if a learning design calls for a shared whiteboard, for example, and there isn't one on the participant's instition's network, what happens?

All of these questions can be answered, but whether they will depends not so much on CopperCore in its present form, but on the community of developers and, crucially, educators that it will attract.

The motherlode

CopperCore source code, binaries and documentation is available on the SourceForge CopperCore page. The software is licensed under the GPL, but as no static linking is necessary, commercial vendors can integrate it into their products.

More information on CopperCore is available on the OUNL's Learning Networks pages

Related items:


Creative Commons License This work is licensed under a Creative Commons License.

syndication |publisher's statement |contact us |privacy policy

 go to start of page content