The JLeRN Experiment

JISC's Learning Registry Node Experiment at Mimas

Archive for the month “February, 2012”

JLeRN at the CETIS Conference 2012

The JLeRN Team and Steven Cook from Jorum are at the CETIS Conference 2012 to present on our work, as part of the Learning Registry session there. We’ll expand this post after we’re done and have had some discussion and feedback: in the meantime, here is an updated introductory handout, and our slides:

Nginx server is famous

Last week there was the Dev8D developer conference 2012 in London, and JLeRN proudly threw an exciting challenge to the community to work with the innovative JLeRN project. I was managing and promoting the challege, and participated in JISC Observatory challenge which was focused on presenting views on emerging technologies which can call attention to innovations that can provide important benefits over the next 3 to 5 years.

I presented the most important features for the Nginx server which runs in background for the learning registry node and explained during a recording time of about 5 minutes and was awarded second prize!

Dev8D Award to Bharti Gupta

Dev8D Award to Bharti Gupta

The points addressed were:

  • What about this recent change (innovation) in technology do you consider important?
  • Have you been involved with or seen promising development projects related to this innovation?
  • What is your vision of how this should develop in 3 to 5 years, and what do you see as ultimate challenges and benefits?
  • If you could wave a magic wand, which obstacles to maximising positive outcome would you remove and why?

Here’s a brief overview of Nginx server:

For the better part of the last decade, the choice for Web server software has been pretty stable. Apache has been used on the majority of Web servers while Microsoft’s IIS (Internet Information Services) is used across many of the rest. Over the past few years, however, use of a third entrant, Nginx (pronounced “engine-x”), has been on the rise, thanks to the software’s ability to easily handle high-volume traffic.

Nginx is already run on 50 million different Internet domains, or about 10 percent of the entire Internet, the developers of the software estimate. It is particularly widely used on highly trafficked Web sites, such as Facebook, Zappos, Groupon, Hulu, Dropbox, and WordPress. Not surprisingly, the software’s creator, Igor Sysoev, designed Nginx in 2004 specifically to handle a large numbers of concurrent users — up to 10,000 connections per server. A white paper on this can be found here

The Hackday: Report and Reflections

The JLERN Experiment and JISC CETIS co-organised a Learning Registry Hackday on January 23rd 2012, hosted by Mimas at Manchester University. Lorna Campbell from CETIS has already written a great blog post (which now includes some excellent discussion below the line) summarising some of the issues that were discussed.

I wanted to report from a JLeRN point-of-view what happened at the Hackday, and what we got out of this event. Our aim was to get the UK folk who were already doing stuff around the Learning Registry in a room with those who were starting to think about doing stuff, to talk about use cases. And we wanted to get some technical people in a room with the JLeRN developers to play around with publishing and accessing data through the JLeRN node.

Before JLeRN started CETIS were already on the case in forming a community of interested folk in UK HE. And Pat Lockley, when he was still at Nottingham University (he’s now at Oxford University), attended the first ever Learning Registry Plugfest in the US (see his report here). So we had a room full of early adopters and experts in the Learning Registry, alongside some new folk with great ideas.

Plan for the Day

We started the day with a blissfully brief presentation session, just an hour long before lunch. Lorna Campbell gave us an overview of the Learning Registry and JISC’s involvement with it. I talked everyone through what JLeRN is doing, with the help of this handout, which summarises some of the options from the Learning Registry specification: Communities, Networks, Nodes.  John Robertson of CETIS finished with an introduction to paradata.

After lunch everyone introduced themselves and what their interest in the Learning Registry was. This was where some interesting ideas and use cases started to emerge.

One Outcome: Concrete Proposals to JISC OER RI Funding Call

It also became apparent that several participants were intending to submit project proposals involving JLeRN and/or The Learning Registry to the JISC OER Rapid Innovation funding call. As it turned out, four proposals (that we know of) that were discussed here were submitted; we won’t know whether any of them were funded until March, but it was great to get so much concrete interest out of the day.

Who Came and What They Said

CETIS’s Scott Wilson was there; he was interested in the Learning Registry from the point of view of a project he’s involved in, which is developing “a Widget Store aimed at the UK education sector using a codebase shared across and sustained by a range of other EU projects and consortia”. Scott wanted to see if the Learning Registry could offer solutions for sharing paradata about educational widgets.

With our proximity to the national learning resource repository Jorum, also based at Mimas, we were delighted to see Ben Ryan, the new Jorum Technical Manager, and Steven Cook, one of Jorum’s developers. Jorum has a great interest in usage data and other forms of paradata, and had been promising to share data with JLeRN from the start. This event turned out to be an excellent opportunity for their new technical manager to get up to speed. Plus, Steven Cook, who is working on a framework and dashboard for Jorum usage stats, was inspired to start developing ways to get that kind of data out of Jorum, together with resource metadata, and into a Learning Registry node. Watch this space: Steven will be blogging here!

Tatiana Novoselova and Andrew Green came from the University of Liverpool, bringing with them lots of experience and ideas around sharing data about engineering learning resources. They had already been trying to grapple with the Learning Registry, and found the Hackday helpful in ironing out some technical issues they had been having, partly thanks to Pat Lockley’s presence and support, and partly thanks to the JLeRN technical team. They reported here.

Terry McAndrew came from JISC TechDis, with some great ideas about how the Learning Registry might allow the educational content community to finally start getting some traction on how to usefully share information about accessibility of resources. It’s always been very difficult to get metadata standards to accommodate accessibility data, which is often, basically, about a user’s experience of a resource, or about the features of a resource as they relate to a user’s individual requirements. Lorna’s post summarises this discussion.

Suzanne Hardy and John Peterson came from Newcastle University, full of ideas from the more complex end of the paradata spectrum: their Dynamic Learning Maps as educational context of use / curriculum data around resources. Watch this space: I’d like to get some more out of them about their ideas!

Julian Tenney came from the University of Nottingham with some great ideas about gathering good paradata from users via the Xerte content authoring tools. He felt it important to start to think about ways that content authors and educators will actually be able to contribute contextual data as part of their usual workflow. Another space to watch.

Richard Goddard, formerly of MrCute (Learning Objectivity) and Alastair Hole came from Worcester College of Technology with an idea about developing a tool that will help record actual educational usage of resources (as distinct from merely hits/downloads). Once this data is recorded, wouldn’t it be great to share it via the Learning Registry?

Jenny Gray from the Open University has had an interest in the Learning Registry since before JLeRN, from the point of view of the OU’s LearningSpace, came along and had some fruitful chats with Nick and Bharti, and Pat Lockley, about options for publishing LearningSpace data and paradata in the node. Like Jorum, she’s interested in how to get an OAI-PMH feed into a Learning Registry node. She reported back on her own blog here and followed up with some more thoughts, and questions, on sharing LearningSpace paradata here (to share or not to share?).

Matters Arising

Note: these action points and issues are not a to-do list for JLeRN, or even for the Learning Registry! They are just a note for when future plans are discussed, and for JISC and other stakeholders to take note of.

  • We need to more fully develop some concrete use cases. E.g. a simple Accessibility “Like” button that could start to capture accessibility info of use to users.
  • We need to develop some demonstrators. E.g. a desktop widget or browser plugin that captures info on user, resource, content, and context of use, with a simple interface.
  • We need to think about how we interact with a node to share and call complex paradata (e.g. Dynamic Learning Maps type stuff).
  • We need to start defining the structure of paradata for various use cases. E.g. we need to look at the concept of ‘actor’ as currently specified for paradata.
  • Note that running a node is a cost, and the JLeRN node will only run for the life of the project (until July 31 2012); need to think about business model and business case for node services; folk can build their own tools and services on top of nodes. People will not feel motivated to start building on something that is still experimental and has an uncertain future.
  • Might be an idea for JISC to take a similar approach to developing SWORD: a series of simple tools to put and get data into JLeRN.
  • Running a node on Amazon Web services (i.e. on a cloud service) has unpredictable costs; this is not generally liked by UK university finance departments!

Data sources for JLeRN

A final note to ourselves: some excellent suggestions from the floor, and thanks to Lorna for taking these notes!

  • Jorum
  • Xpert
  • OU
  • NHS eLearning Repository
  • DLM NBBS programme data
  • FE Data sources like NLN? XTLearn
  • Open Spires podcasts
  • Delicious / Diigo
  • Merlot
  • NDLR

Next Steps

JLeRN are about to attend the Learning Registry session at the CETIS Conference 2012, like, tomorrow. And we are still calling for entries to our Dev8D JLeRN Paradata Challenge (due Friday midday).

After that, we have five months to go until the end of JLeRN. What should we be focusing on? Discussions are ongoing, we’ll report back here, let us know your thoughts!

The Windows Node at Mimas

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 were some issues on getting Nginx setup right though.

Then after some tweaking, Nginx goes smoothly on the Windows 2008 server after restarting the machine, but wasn’t sure why the step to push the couchapps not working. I was trying to navigate to the config folder of the LR repository
cd C:\Python27\LearningRegRepository\config
and ran the command

python setup_node.py

and was getting the following error:

Traceback (most recent call last):
File “setup_node.py”, line 12, in
import couchdb
ImportError: No module named couchdb

Checked the python code, and couchdb folder is very much existing.. well I knew now is the time to “DEBUG” which I guess I love the most. Lou on the US Learning Registry team suggested to download version 1.1.1 from https://github.com/dch/couchdb/downloads

Damon Regan from the US Learning Registry team noticed the blog post and was happy about the work on Windows machine. He mentioned that Lou Wolford on the LR team has worked with getting the LR running on Windows. There is an active pickling error that they’re working to resolve. He shared the discussion thread on that: https://github.com/LearningRegistry/LearningRegistry/pull/167 and discussions were happening on the Windows mods during the dev calls. He hoped that all issues get resolved and I can get it up and running soon.

Later on I managed to resolve as per Jim’s suggestion for Ubuntu on https://groups.google.com/forum/#!msg/learningreg-dev/0sKsLb15fi8/hFFhObPk69IJ


cd ~/gitrepos/LearningRegistry/LR
pip install -e ./

That should install ALL LR dependencies outside of wsgi, then:

cd ~/gitrepos/config
python setup_node.py -d

I used the same version of couchDB as Lou suggested. The pickling error was still persisting and I was going through the discussion thread Damon mentioned in his comment.

Lou commented that they are looking into a solution that looks for what OS is running and switches between threads/processes to keep everything stable no matter what OS is being used. He promised to keep me updated and let me know ASAP when it is released.  Damon mentioned that John Poyau from the LR team is working on a new factory model to allow windows platforms to use threads and linux and mac platforms to use process. Then in few days, John was able to fix the issue by switching to use Thread instead of Process in change_monitor to fix the pickling_error in Windows. Also he tweaked the way test files are declared to be Windows-friendly.

Damon mentioned that the fix is tested on Windows, Mac and linux. He also mentioned that the fix is not formally released yet. but is in their stable master. He recommended to update our experimental windows node at Mimas from the stable master to obtain the fix. He suggested following steps as well to upgrade the node to master


1. Pull the most recent tag from git

cd /LearningRegistry
git checkout master
git pull

2. Run the setup node python script

python setup_node.py -d

Then he mentioned that it is important to re-run the setup node python script as configuration changes take place during updates. The LR team hopes to have an update script soon that will preserve our node settings on update.

Now I have followed Damon’s steps and do not see the pickling error anymore, and able to start the server on localhost. Watch this space for further development on the Windows environment.

Jorum OAI-PMH data published

The starting point for this experiment was a document written by the LR developers in the U.S., the OAI-PMH to Learning Registry Publish Utility.  I installed the Python OAI-PMH third-party module and started working with the Python script provided by the LR developers, LR-harvest-and-publish.py.  The script needed some code to handle basic authentication with our JLeRN alpha node.  Then I successfully published some sample Jorum data but the JSON documents weren’t quite right.  The resource_locators (URIs) were incorrect and the keys (subject terms) were missing altogether.  In the case of Jorum, the keys correspond with Dublin Core subject terms in the OAI-PMH data.  I installed the Python ElementTree third-party module in order to parse the OAI-PMH data.  Then I located the subject terms and inserted them into the JSON document before publishing; that is, the LR application indexes the keys when the JSON document is published.  Then I managed to harvest all the Jorum OAI-PMH data and published it on our node.  (We have put our code in a repository on Github in case others can benefit from anything we happen to write.)

Example queries:
http://alpha.mimas.ac.uk/obtain?request_ID=http://dspace.jorum.ac.uk/xmlui/handle/123456789/1000
http://alpha.mimas.ac.uk/slice?identity=jorum
http://alpha.mimas.ac.uk/slice?identity=mimas
http://alpha.mimas.ac.uk/slice?any_tags=curve
http://alpha.mimas.ac.uk/slice?any_tags=magnetism

Pre-Dev8D JLeRN Developers’ Challenge Surgery

So the JLeRN Developers Challenge at Dev8D  is up and posted on the Challenges page on Dev8D, and invite your brilliant ideas and entries.

There shall be a dedicated one hour pre-Dev8D surgery on 6th February, 2011 from 10:30-11:30 am and is open for any queries or assistance. You are more than welcome to find more about the challenge or the JLeRN project itself during the surgery.

To participate in the challenge, please drop in a quick email on Bharti [dot] Gupta [at] manchester [dot] ac [dot] uk. You should receive an immediate response acknowledging your interest in the challenge along with the details of how to proceed and connect to the development environment. Please feel free to go through our blog posts which points to most of the work we have been involved in.

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: http://alpha.mimas.ac.uk

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:
http://alpha.mimas.ac.uk/status
http://alpha.mimas.ac.uk/description
http://alpha.mimas.ac.uk/obtain  [all documents in node, 100 at a time]
http://alpha.mimas.ac.uk/obtain?request_ID=http://dspace.jorum.ac.uk/xmlui/handle/123456789/1000
http://alpha.mimas.ac.uk/slice?any_tags=curve
http://alpha.mimas.ac.uk/slice?any_tags=magnetism

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 http://alpha.mimas.ac.uk/obtain?request_ID=”http://alpha.mimas.ac.uk/obtain?request_ID=http://dspace.jorum.ac.uk/xmlui/handle/123456789/1000″
$ curl -Xv POST -H “Content-Type:application/json” “http://alpha.mimas.ac.uk/publish” -d @test_data.json -u fred

The Learning Registry Quick Reference Guide has more examples.

JLeRN Experiment Paradata Developers’ Challenge at Dev8D 2012

Are you interested in capturing, sharing, mashing up or otherwise using paradata, AKA data about the use of open educational resources?

Are you thinking about exploring where and how teachers and learners are using resources, or sharing them via social media, or what they are saying about the resources?

The JLeRN Experiment has a challenge for you!

Please see the Dev8D Challenges page for further details on this and other Developer Challenges, or see our own page here.

And please help us out by letting folk know about the challenge.

NB: There will be a pre-conference Web surgery for developers on 6 February, 10:30-11:30.

Post Navigation

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: