The JLeRN Experiment

JISC's Learning Registry Node Experiment at Mimas

Archive for the tag “learning registry node”

Taster: a soon-to-be released ENGrich Learning Registry Case Study for JLeRN

One of the tasks we’ve commissioned from our informal task group is a case study from Liverpool University on why and how they have implemented a Learning Registry node to enhance access to high-quality visual resources (images, videos, Flash animations, etc.) for use in engineering education. The ENGrich team will be presenting their case study at the JLeRN Final Workshop on Monday 22nd October and completing it based on feedback and discussion there; but we’d be interested in any questions or points you have as well prior to the final version being published here.

So, here is your taster:

Ins and Outs of the Learning Registry: An ENGrich Case Study for JLeRN – draft

By the ENGrich Team at Liverpool University. This work is licensed by The University of Liverpool under a CC BY-SA 3.0 Unported License CC-by-sa icon

A brief summary of the ENGrich project

ENGrich, a project based at the University of Liverpool, is both designing and developing a customised search engine for visual media relevant to engineering education. Using Google Custom Search (with applied filters such as tags, file-types and sites/domains) as a primary search engine for images, videos, presentations and FlashTM movies, this project is then pulling and pushing corresponding metadata / paradata from and to the Learning Registry (LR). A user-interface is also being developed to enable those engaging with the site (principally students and academics) to add further data relating to particular resources, and to how they are being used. This information is published to LR, which is then employed to help order any subsequent searches.

ENGrich process flow

This section will detail the process flow of the proposed service. Effectively, the LR plays a central role in ‘engriching’ visual engineering content, above and beyond the basic data returned by Google Custom Search.

ENGrich Process Flow Diagram

ENGrich Process Flow Diagram

Working with documentation

This section will cover how we worked through the available LR guides and documentation, from the very basic methods (publish, slice etc) to the more customized data services (extract).

The list includes:

Learning Registry in 20 Minutes or Less

Learning Registry – Quick Reference Guide

Learning Registry – Slicing

Paradata in 20 Minutes or Less

Modeling Paradata and Assertions as Activities

Paradata Cookbook

LR Data Services

Setting up a Learning Registry node at the University of Liverpool

This section will explain the rationale behind the decision to set up an institutional LR node (common node) at the University of Liverpool, and challenges and issues we faced while doing it. This node is to be utilized by the project, as well as providing a means of highlighting the wider potential of the LR to other centres / services across the University.

Summer students identifying learning resources

This section will describe how the project employed undergraduate engineering students over the summer of 2012 to classify visual media available online that are relevant to the University of Liverpool engineering modules. The project relies on their experience as engineering students to provide insights into learning techniques of how to identify resources that will aid future students. 25,000+ records were linked to the appropriate modules, and are ready to be published in the University LR node using the paradata templates described below.

The students blogged every week on their tasks and progress.

Paradata statements templates

This section will report on how we went about creating the required PHP templates to publish the students’ data into our Learning Registry node. We have constructed a set of contextualized usage paradata statements for different types of actions (e.g. recommended, aligned, not aligned) and so far have published a couple of test documents to our University LR node.

Slice, harvest, obtain methods and data services (extract)

This section will summarise our experience with different methods the LR has in place for accessing data from the LR. We report on using slice, obtain, harvest and extract methods, explaining why we have chosen one over the other.

University of Liverpool student portal – using data directly from LR

This section will demonstrate how an iLIKE ‘widget’ (a portative version of ENGrich visual search) could be implemented within the University of Liverpool student portal. The iLIKE prototype gets a unique listing of identifiable University of Liverpool engineering modules (titles and codes) directly from the Learning Registry as the user types into the text field, and then fetches the latest resources relating to that module from the LR. It dynamically generates the thumbnails corresponding to the resources.

Working with Mimas

This section will talk about how we collaborated with the JLeRN team at Mimas to resolve some initial bugs in the slice service; to draw on their experiences in setting up a new LR node at the University of Liverpool; to develop a set of customised extract data services; and also about the possibility of joining the LR nodes at Liverpool and Mimas using the LR distribute service.

What next…?

We have been looking at options to further work related to the JLeRN node and paradata, basically to create a sample interface. Javascript will be used mainly for the front-end, though it is all in primary stages. With all the data we have currently in our JLeRN node, it would be good to have a way to explore it and use it through a web client. Currently it is not fully clear what we might end up with, but some basic wireframes for the web pages are considered. Next we will look at the sharing and synchronising of learning resources across the Alpha node on Ubuntu OS and the Beta node on Windows 2008 OS.

Keep watching this space on more progress.

Alpha node

We installed the JLeRN “alpha” node on our new Ubuntu server on the weekend (Jan 21-22) before the Hackday.  But there was a bug which affected the indexes and thus document retrieval.

The LR developers in the U.S. resolved the bug promptly and we applied the fix on Jan 28th.

The node is here:

The node supports all publish and retrieval services although we haven’t had a chance to test all of these yet.

The node is now open to the world except you need a username and password to publish documents.  The credentials you need to publish are:

Username: fred
Password: flintstone

Give it a go when you have a minute or two.

Examples:  [all documents in node, 100 at a time]

N.B.: The examples above fetch JSON documents.  Install an extension to your favourite browser so you can display the documents in a readable format; e.g., JSONview extension for Firefox.

Curl examples:
$ curl  -v”″
$ curl -Xv POST -H “Content-Type:application/json” “” -d @test_data.json -u fred

The Learning Registry Quick Reference Guide has more examples.

Java on Learning Registry…

The JLeRN Hackday was such an involving and learning event. Got few more doubts clear with Nick and got a chance to speak with Scott regarding his work on LRJavaLib – the Java library for the Learning Registry services. I downloaded bencode from, untar it, and installed the jar file using Maven.

Now am trying to develop some Java code to automate all the services using JAX-RS using Eclipse IDE.

Also need to look at the Data Services proposal, which seems quite promising from the Developer’s list on

Communities, Networks, Nodes: Where to next for the JLeRN Experiment?

NB: I’ve prepared a simplified handout version of this post for the JLeRN / UK Learning Registry Contributors’ Hackday, available on Googledocs to print out or download here.

So what’s this all about again?

Are you feeling a bit baffled by the Learning Registry concept? By the JLeRN Experiment? But excited by some of the possibilities that trickle through the confusion as you start to get a handle on what we’re doing? Join the club.

The Learning Registry project worldwide is starting from a very techie place, and we are only beginning to imagine how that might eventually impact on services for teachers and learners, and the support staff who help them with using resources.

We’ve learned from the mis-steps of years past where we fumbled through if-we-build-it-they-will-come and if-only-someone-would-create-one-uber-repository/portal. We’re focussing on what we’ve been told over and over by educators for years: that recording and analysing and understanding and disseminating and using data about use of learning resources should be at the centre of resource provision and management. We’re calling that data ‘paradata’.

So, how will we, the UK-based JLeRN Experiment, take forward our investigations? We need your feedback. Please read on for options and questions.

The building blocks

The Learning Registry folks have produced some well-written and well-conceived specification documents, which outline clearly the kinds of decisions that different participants (not just JISC) could make at a policy level here in the UK. I will summarise below (a) what we’re doing right now, and (b) what some of the wider options are for implementing Learning Registry nodes, networks and communities.

NOTE: nodes, networks and communities are the three levels of togetherness available to educational communities wanting to share resource data and paradata. We can:

(1) share our data with others via a single node;
(2) widen our sharing to a network of nodes that share the same policies about access etc.; and
(3) widen our sharing even further within communities of networks.

More below!

If you really like to read full specs, check out this openly available Googledoc; it’s the main specification document this post quotes from (it’s very readable as specs go): The Resource Distribution Network Model: Learning Registry Technical Specification.

From that document, here is a visual representation of how Learning Registry nodes, networks and communities relate to each other and to external producers and consumers of data. You may need to refer back to it as you read on.

Learning Registry Resource Distribution Model Diagram

The Learning Registry Resource Distribution Model Diagram

The JLeRN Experiment at Mimas

So, Mimas was asked by JISC to set up a Learning Registry node and play with it, with help from JISC CETIS and an informal task group of interested folks in UK education, to see what we could learn. That was about all any of us understood about what was needed at that time.

We’ve had a working node at Mimas for some weeks now, which has led to acquisition of skills and understanding for our devs Nick and Bharti, and we are busy getting our node set up on a dedicated server to allow anyone to experiment with getting their data in and out.

We’ve since discovered that there are a number of options for nodes, and there are also possibilities for networks of nodes, and network communities. These are described in more detail further on in this post. We have implemented a common node, without requiring signatures to push and pull data out of the node (in other words without the basic security restriction available). A common node is defined thusly:

Common Node: A common node MAY provide any of the node service classes listed. If provided, the distribution services of a common node SHALL be limited to connecting to other nodes in the same network (the distribution service MAY connect to multiple destination nodes).”

There’s only one other kind of node: a gateway node.

I bet all that just raised a bunch of questions for you, right? Read on!

Where to from here?

Let’s talk about nodes

Nodes are the building blocks of the Learning Registry. They enable decentralised networks for sharing data about learning resources and their use. Anyone can set up a node wherever they like by installing the node code and making it available to whomever they like*. They can also restrict access if they choose. Those who share data via that node can publish their data to the node, or extract anyone’s data from the node. A completely open node allows literally anyone to publish or access data.

NOTE: There are two kinds of node: common nodes and gateway nodes. Each kind of node supports distinct activities. Basically, a common node can support all the different specific services you need to push, pull, distribute and process resource data with any number of external sources, and within a given network of nodes. A gateway node allows different networks to connect with each other to share data. (Might be an idea to scroll back up and look at that diagram again!).

common node is defined further up the page, and its possible services in the next section. A gateway node simply provides a data distribution connection between one network and another, because nodes cannot belong to more than one network, and a clearly defined pipeline is needed, for security and other policy reasons.

Until the JLeRN Experiment has some pressing use case for testing a gateway node, we’re working with a common node for now.

What can a common node do?

Common nodes can offer five kinds of service:

  • Publish Services allow data to be published to the node from external sources. We can choose which publishing APIs we will support (e.g. SWORD), but we have to (and we do) support the Basic Publish Service. NOTE: we’re talking about how we might get data into JLeRN’s Node at Mimas from a Jorum OAI-PMH feed, which will likely involve some scripting as it’s not provided as part of the core node set-up.
  • Access Services allow data to be pulled, or accessed from the node or the distribution network the node is part of. Again, different APIs (e.g. OAI-PMH) can be, but don’t have to be, supported.
  • Distribution Services allow data to be replicated and transferred between nodes.
  • Broker Services allow us to “augment, transform or process resource data held at that node to produce new or updated resource data for access or distribution”. Interesting!
  • Administrative Services, which “are used to query a node to obtain its status or to trigger node administrative actions.”

So: what kinds of services would you like to trial with the JLeRN Experiment? What do you think should be trialled?


Resource distribution networks

You’ll have noted already that common nodes can be part of networks, and that networks can be connected via gateway nodes. When networks are connected, this is called a network community. Here’s what a network (or resource distribution network) is:

“A resource distribution network is a group of one or more connected nodes, with each node providing node services. All nodes in a resource distribution network operate under the same policies. Multiple resource distribution networks MAY be established.”

Important things about networks are:

  • Any given node can only be part of one network; the node is subject to the policies of that network. A gateway node is necessary for a common node to connect to a different network.
  • Network policies include such things as security requirements for sharing data via nodes in the network, e.g. whether signatures are required, data deletion policies, and so on.
  • A network can be part of only one community (so if you want your node to interface with other communities, you’ll need to set up and connect via a gateway node. Again, scroll back up to the diagram!).

So, what about network communities?

Network communities

OK, if you’ve managed to read this far, you can read the specification document definition! It doesn’t really require paraphrasing:

“A network community is a collection of interconnected resource distribution networks. A community MAY contain one or more resource distribution networks. A resource network SHALL be a member of only one community. Gateway nodes provide the connectivity between resources networks within a network community and MAY provide connectivity between networks in different communities. NB: A gateway node that provides an intra-community network gateway is undifferentiated from one that provides an inter-community network gateway.”

The important thing to note about communities is that open communities, known as social communities, and closed communities are both supported.

These are fairly self-explanatory: social communities can connect to each other via gateway nodes to share data. Closed communities only allow sharing between nodes and networks within their own borders. At the moment, the Learning Registry project itself has both kinds. The Learning Registry is a social community, and The Learning Registry Testbed is a closed community for developers to work on the code and the specs.

NOTE: At the moment, we are thinking about setting up a node to be part of the Learning Registry Testbed closed community, but we are, as previously noted, currently only running a node that is not yet part of any network or community, and that we are making available for anyone to test publishing and accessing data with.

So that’s where we’re at! What next?

We’re taking advantage of our proximity to the Jorum repository of open educational resources at Mimas to start exploring data and paradata around Jorum’s stuff, and how these might interact with the Learning Registry to the eventual benefit of Jorum’s users. There will be a blog post soon on the Jorum team blog saying a bit more about that.

We’re hosting a hackday in collaboration with JISC CETIS on Monday 23 January 2012, here at Mimas in Manchester. We’ve got ca 10 people coming from the UK education community, and we’re going to let them at our node to test out whatever folk want to test. We’ll also be brainstorming ideas for the future, use cases, and what the UK HE community wants from the JLeRN Experiment over the next few months. We’ll try to get a few folk tweeting from the event: follow and ask questions via hashtags #learningreg and #jlern  And there will be a blog post or two reporting back.

Then we’re participating in another session with JISC CETIS at their conference in February where we hope to do a bit more talking about ideas and a bit more hacking and some finalising of requirements on the JLeRN Experiment. This session will include a broader view on the entire Learning Registry project as well. I think there are still places on this so book up if you want to come!

Watch this space, and please comment here on the blog if you have any questions, inputs, or indeed corrections to any misunderstandings on my part in the text above!

* NB: The Learning Registry specifications and software are all still very much experimental and under development. The JLeRN Experiment is running concurrently with Learning Registry developments worldwide. So everything is subject to change, improvement, and undiscovered bugs and issues at the moment.

Some more exploring…

Hi this is Bharti and am one of the developers here at Mimas and working with Sarah and Nick on the JLeRN project. I got lucky enough to get chance to work on this exciting experimental work on establishing a UK node. and I had a good one day of self learning about the Learning Registry (LR) and then got chance to speak with Dan Rahek from the LR team. Quite a reminder of what he presented on LR project in the Repository Fringe event last year in Edinburgh.

Well, there are definitely many challenges to face, but am sure we can crack the puzzle. Worked to establish a node on the Windows Server 2008 machine and after some tweaking and self learning got through quite far installing the node.There are some issues on getting Nginx setup right though.

We have the hackday coming up on 23rd January and hope to get some nice JORUM data to play with. There are different mechanisms to let the data talk to the node, and I am keen to explore the Java library that may be used to publish data to, and harvest from a LR node..

Keep watching this space for more developments in this R&D project!

Node of Mimas

Nick here.  I work at Mimas with Sarah and Bharti.  I installed a node in mid-December on a spare machine I had lying around.  As it was nothing “official” I called it Node of Mimas.  One simple way of looking at the node’s status is to execute a command like this:

$ curl http://<…>/status

{ “node_name”: “Node of Mimas”, “node_id”: “7ee34ddd8e4f4ea4aafd59c3c7619a16″, “active”: true, “timestamp”: “2012-01-11T20:32:01.097068Z”, “start_time”: “2011-12-31T10:01:07.698981Z”, “install_time”: “2011-12-14T14:44:24.206372Z”, “earliestDatestamp”: “2011-12-14T15:34:23″, “doc_count”: 1 }

You might notice the output from this command is a pretty JSON document.  This node was installed on December 14th and last restarted on New Year’s Eve.  It contains one document.  I wonder what it is?  Execute the following command to find out:

$curl http://<…>/obtain

{“documents”:[{"document": [{"doc_type": "resource_data", "resource_locator": "URI_of_resource", "resource_data": "Put_anything_like_metadata, xml_or_whatever_here", "update_timestamp": "2011-12-14T15:34:23.219869Z", "keys": ["science", "what_ever_you_want"], “TOS”: {“submission_TOS”: “;}, “_rev”: “1-f81b1258b28092a314661527ad7dcbf0″, “resource_data_type”: “metadata”, “payload_placement”: “inline”, “payload_schema”: ["hashtags", "describing", "resource", "format"], “node_timestamp”: “2011-12-14T15:34:23.219869Z”, “doc_version”: “0.23.0″, “create_timestamp”: “2011-12-14T15:34:23.219869Z”, “active”: true, “publishing_node”: “7ee34ddd8e4f4ea4aafd59c3c7619a16″, “_id”: “551592f1743d46a7b4f4d6c7484e356a”, “doc_ID”: “551592f1743d46a7b4f4d6c7484e356a”, “identity”: {“owner”: “”, “submitter”: “Your name or organization here”, “submitter_type”: “agent”, “signer”: “Your name or organization if signing the document”, “curator”: “”}}], “doc_ID”: “URI_of_resource”}]}

Let’s make the output more readable for humans (and edit it slightly):

JSON document

Sample document

Well, it’s just a test document, in JSON format, but it gives you an indication of what Learning Registry data looks like.

The Hackday in Manchester is fast approaching.  We are expecting to be given a new server by the end of this week but it will take a few days to install and test a new node we are calling Alpha.  By the middle of next week we will decide which node to use for the Hackday, either Node of Mimas or Alpha.  That’s all for now.

Welcome to The JLeRN Experiment at Mimas

Welcome to the JLeRN blog!

We’re a small team at Mimas in the UK, working on a JISC-funded experiment, setting up and testing a node as part of the U.S.-based Learning Registry project:

“JISC will be participating in the Learning Registry project by setting up an experimental node in the UK with a focus on content from the higher education and cultural sectors. Utilising the expertise and content available to JISC, the project will explore contributing data and analysing it. JISC hopes to collaborate with the Learning Registry in exploring the infrastructure considerations and to help specify and support useful applications.”

We’re collaborating across the globe with other edtech development teams on this technical proof-of-concept initiative. The Learning Registry is exploring the development of a decentralised network of nodes for sharing ‘paradata’ about learning resources and their use:

“Paradata provides a mechanism to openly exchange data about how resources are discovered, assessed for utility, and integrated into the processes of designing learning experiences. Each of the individual and collective actions of favoriting, foldering, rating, sharing, remixing, embedding, and embellishing that are the hallmarks of today’s teacher workflow around digital content are points of paradata that can serve as indicators about resource utility and emerging teacher practices.” - NSDL page on the Learning Registry site.

The team consists of me, Sarah Currier, leading the effort, and two awesome developers, Nick Syrotiuk and Bharti Gupta.

We’re going to use this blog to share all of our adventures, mis-steps, solutions, and creative ideas while working on the Learning Registry. It’s open notebook science in action!

We’re also staying in close communication with JISC CETIS, who have a separate watching brief and advisory role on behalf of the UK with the US Learning Registry project. John Robertson, Lorna Campbell and Phil Barker have already been a great help. I highly recommend following the links on John and Lorna’s names there, to read some useful, accessible blog posts on the Learning Registry. You might also want to check out the presentations and guidance documents here, follow the project on Twitter at @learningreg and #learningreg, and read Learning Registry maven Dan Rehak‘s guest blog post for CETIS here.

And we’ll be working, of course, with the Jorum team, also based here at Mimas, as one source of learning resource data.

We’d like to work with any technical teams who would like to experiment with the node we are setting up. If you have data and/or you are setting up your own node, and wish to collaborate with us, please get in touch: sarah [dot] currier [at]

Post Navigation


Get every new post delivered to your Inbox.

%d bloggers like this: