RedFeather Configuration 1 – Philosophy
One of the greatest barriers when deploying a full-scale repository platform such as EPrints is the amount of configuration required to take the software from its “out of the box” state to something suitable for teaching and learning. Installing the EdShare suite of extensions takes you a great deal of the way by providing simplified workflows, in-browser previews of documents, collections, user profile pages and more. However, tweaking these base settings to perfectly match your requirements still requires a certain familiarity with the inner working of EPrints itself.
With RedFeather we want to try and provide a system that will satisfy the requirements of 90% of users with almost zero configuration – the idea of a repository you can fully deploy in a single afternoon is very appealing to us. Of course, we don’t want something that is not flexible enough to be useful to that final 10% of expert users who want to go the extra mile.
At this point in the project I’ve already done a great deal of work prototyping various different ways of providing customisation, ranging from highly granular configurations where each individual component can be seamlessly interchanged, to complete fixed configurations which are coded to only do exactly what we want. Both approaches have their advantages but the main motivation behind RedFeather is that the system should be simple and forsake all the complexity so inherent in existing repository platforms. This has led me to the following philosophy for the design:
1 ASSUME ONLY MINIMAL VARIATIONS
Cater primarily for the 90% of people who will deploy RedFeather with the default workflow, metadata and look-and-feel but make it easy for them to change very minor parts of the site such as the header, footer and stylesheet.
2 PRIORITISE SIMPLICITY OVER FLEXIBILITY
Do everything in a way so simple that changing it is trivial for anyone with even basic knowledge of html and PHP. Don’t try to anticipate how more advanced users will want to customise the code – just make it easy for them to understand the existing system and leave the rewriting to them.
RedFeather Project Plan
Project Overview
Currently there are significant barriers to individuals or smaller groups publishing OER materials. They can upload their work to a website, but rich media is effectively dark to search engines without adequate metadata, in addition they may forget important licensing information, and materials published this way are invisible to national indexers like Jorum or Xpert. RedFeather (Resource Exhibition and Discovery) is a proposed lightweight repository server-side script that fosters best practice for OER, it can be dropped into any website with PHP, and which enables appropriate metadata to be assigned to resources, creates views in multiple formats (including HTML with in-browser previews, RSS and JSON), and provides instant tools to submit to Xpert and Jorum, or migrate to full repository platforms via SWORD. RedFeather will require no significant technical expertise and no database, but will provide a simple and effective repository solution for smaller projects, individuals, or those seeking to demonstrate OER in order to justify a more significant investment in an organisational repository. RedFeather will be demonstrated and evaluated in collaboration with the University’s Archeological Computing and Digital Economy Research Groups.
Anticipated Outputs and Outcomes
- As well as making the creation of OER materials more straightforward RedFeather will foster OER best practice and fits into a number of the key areas identified by JISC:
- It’s main impact will be to improve resource description, at present OER creators seeking a simple solution merely add their resources to a website, and for rich media types this effectively makes them part of the dark web. Using RedFeather will encourage minimal but significant metadata – such as titles, keywords and licensing information – that will make resources more visible to search engines. In addition the multiple views that will be offered by RedFeather (such as RSS, RDF, and JSON) will make resources far more visible to crawlers and other automated systems.
- In addition RedFeather will be specifically designed to promote and enable aggregation and discovery, by using SWORD to link with key OER indexers such as Xpert and Jorum. RedFeather will provide a lightweight gateway through which users can experiment with OER, and yet still participate with national efforts.
- Finally RedFeather will provide out-of-the-box tools to support social recommendation, encouraging users to use social tools such as Facebook, Twitter or Disqus to highlight and share resources. In addition we plan to develop a recommendation plugin based on the Xpert index, which will instantly link RedFeather resources with similar content from the broader OER context.
We anticipate that the Impact of the RedFeather project will be:
- Access to the benefits of OER sharing are widened to users with small, simple cases without the need for an institutional repository
- Previously hidden resources will become available through access to simple OER good practice, increasing the breadth and number of OER resources.
Overall Approach
The intention is that a base install of RedFeather will be a single .php file which can be dropped into almost any web space to provide quick and straight forward access to digital resources.
Have a look at our blog post: who is RedFeather for? which describes the stakeholders in Redfeather and scenarios of use.
Redfeather features will be extended in collaboration with our co-designers to include tools/plugins for social media, recommenders, WordPress
RedFeather interoperability/standards
To ensure productive use of RedFeather we will adopt these standards:
OER Licensing: information based on appropriate Creative Commons licenses
Export standards: RSS, RDF, JSON
Metadata: Dublin Core
RedFeather Deliverables
- RedFeather Core Plugin Framework
- RedFeather HTML View Plugin
- RedFeather RSS Export Plugin
- RedFeather RDF Export Plugin
- RedFeather JSON Export Plugin
- Social and Recommendation Plugins
The software will be made available through the project website (for at least three years )as an Open Source download and licensed for use under Creative Commons GNU general Public License (software).
Project Resources
RedFeather will take an iterative development approach and work closely with stakeholders in both the ACRG and DE USRG. In larger projects we have undertaken the full participatory design process, and we will borrow the more agile elements for RedFeather, for example including stakeholders in project planning, and adopting an agile approach with user meetings acting as a place where stakeholders can participate in the design process. User’s qualitative comments and personal usage stories will also be a core part of the evaluation of the tool, which will be included in the final project report. This user engagement will enable us to tailor the software according to real requirements and needs, and will ultimately result in not only the software becoming available, but also new OER sites that can contribute to the national OER picture, and act as exemplars of what can be achieved with RedFeather
The RedFeather Project team is:
| Dave Millard | Principal Investigator | dem@ecs.soton.ac.uk |
| Yvonne Howard | Project Manager | ymh@ecs.soton.ac.uk |
| Matt Taylor | Developer | mrt@ecs.soton.ac.uk |
Risk Analysis
| Risk Description | Probability P 1(Low) – 5 (High) | Severity S 1(Low) – 5 (High) | Risk Score (PxS) | Detail of action to be taken
(mitigation / reduction / transfer / acceptance) |
| Delay in employing staff | 1 | 5 | 5 | Given the small timescale a prompt start is critical, however a developer is already in place and there is a very low likelihood of any delays. |
| Technical delays | 2 | 3 | 6 | There is a danger that any tool development will take longer than anticipated, or may fail to fulfil requirements. We consider this to be a low risk because of the skill sets present in the development team, however in the event of any delays it will be possible to reduce the scale of the social plugins planned for WP3 in order to ensure successful delivery of the core RedFeather platform. |
Work packages
As a five-month project RedFeather will follow a simple organisation of three work packages (WP1-3) focused on achieving six explicit deliverables (D1-6), and one workpackage focused on dissemination which continue throughout the project. The work package structure is shown below:
WP1: Development
The first work package will set up our co-design team of developers and members of our stakeholder group. The work package will build the RedFeather core, which allows a user to provide metadata for files and creates HTML pages for each file. All components will be plugins so this core will take the form of a simple plugin framework, and a HTML plugin. This will provide the technology framework for RedFeather. The RedFeather core will be available as an on line perpetual beta for testing/ feedback with our co-design team.
Deliverable 1: RedFeather Core Plugin Framework (M2)
Deliverable 2: RedFeather HTML View Plugin (M2)
WP2: Export Plugins
Once the framework is complete, we will work with our co-design team to create plugins to support our use cases, including export plugins for outputting metadata as RSS, RDF, and JSON. Existing metadata schemes/ontologies (such as Dublin Core) will be used wherever possible. The plugins will be available through the perpetual beta deployment set up in WP1
Deliverable 3: RedFeather RSS Export Plugin (M3)
Deliverable 4: RedFeather RDF Export Plugin (M3)
Deliverable 5: RedFeather JSON Export Plugin (M3)
WP3: Deployment and Social Plugins
Finally RedFeather will be evaluated with our early adopters in the ACRG and DE USRG, and final plugins will be developed for social recommendation (e.g. sharing on Facebook/Twitter, commentary and recommendation via Xpert).
Deliverable 6: Social and Recommendation Plugins (M5)
WP4: Communication and Dissemination
Throughout the project will disseminate RedFeather developments and project progress through the project blog. As well as generating interest with our early adopters, we plan to launch Redfeather to the wider OER and repository community at Repofringe 2011. We hope to be able to take RedFeather to OR11 next year.
RedFeather in a nutshell
The RedFeather project aims to fill a niche in e-learning where teachers want to share their resources without the use of a full-scale repository platform. I identified three such groups of users in an earlier blog post (accessible here) but in the interest of keeping this post self-contained we can generalise them to “users who want to share a small group of resources”. While it is possible for these users to simply upload resources to webspace, doing so will provide them with none of the added value they would gain from a repository.
RedFeather is an extremely lightweight repository-like solution that fosters best practice for OER, it can be dropped into any website with PHP, and enables appropriate metadata to be assigned to resources, creates views in multiple formats (including HTML with in-browser previews, RSS, RDF and JSON), and provides instant tools to submit to Xpert and Jorum, or migrate to full repository platforms via SWORD.
A live demo of RedFeather can be accessed from the project page at http://redfeather.ecs.soton.ac.uk/demo.
Seriously, Visual Studio?
Last week Pat gave a workshop about using vim as your programming text editor. In it, he mentioned that vim has branching undo; that is (hold on now, this is complicated) if you undo and start typing again, if you undo back to the same point, you can get back what you originally undid. It’s a bit Back-to-the-Future-meet-your-mother-and-your-sister-disappears, isn’t it?
If you want an understanding of what that means, you should definitely watch this video: Undo branching and Gundo.vim
Anyway, the reason I mention this is that Visual Studio does almost the opposite. It seems intentionally set up to make sure you lose as much of your work as possible. For example, I just undid some typing, but realised I wanted that back. So I hit Ctrl+Y, which isn’t quite the de facto standard for ‘Redo’, but works in most Windows applications. This was my big mistake. Ctrl+Y in Visual Studio is actually the shortcut for Yank dating back to VB6 days. The great thing about that is it’s a forward-moving action. Now undo will just un-yank the line. And now I cannot redo what I originally wanted.
What a mess! Now if you undo and redo, it will just re-yank the line. I have lost that branch of my undo history by clicking the wrong keyboard shortcut.
Now my lesson here isn’t really that it would all be better if we used vim, as branching undo history is an extremely advanced and complicated feature. The real lesson is that Visual Studio is utterly bonkers for overloading a keyboard shortcut that many would use for controlling undo history (Ctrl+Y) with something that edits your code. Bad Microsoft!
Oracle Databases
Yesterday, I was given access to the data cache held by iSolutions here. Well, a view on to it. And it doesn’t have every piece of data we requested (first name, last name, e-mail address, faculty, supervisor, degree title, year of degree and photo), let alone all of the data the University holds (which is our eventual goal).
That aside, I was given the keys to dad’s car and was about to set off on a wild data-ride when I drove straight into the garage door. I know from experience that iSolutions use Oracle as their database system; what I didn’t know is how hard this is to access.
At first I thought maybe I should download a client so I can interrogate my view of the database, before installing the necessary PHP extension to access it programmatically. I found out this client (or part of it) is called SQL*Plus and headed over to the Oracle client download page.
However, after agreeing to the license and clicking the download link, I was hit with this page:
I tried a few different links, I tried going to the registration page, but everything to do with the Oracle sign on process was giving me this error page. “Well forget this client”, I thought to myself, “I’ll just interact with Oracle through PHP”.
Easier said than done!
Obviously my early code didn’t work:
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
The oracle extension isn’t installed yet, so PHP doesn’t know what oci_connect is. “I’ve enabled MySQL before, it can’t be that much harder to enable Oracle”, I confidently muttered. I followed a few instructions:
Installing Oracle libraries for PHP5 on Ubuntu Server 8.04
How To Install Oracle XE in Ubuntu 64 Bit
The main problem I encountered is that in all cases, I have to download the Oracle client. Except I can’t get past that sign-on page! The first tutorial has a solution: add the Oracle OSS repository to your source list and type sudo apt-get install oracle-xe-client. Seems simple, except the repository only has binaries for the x86 version of the client, which apt-get refuses to install if you have an 64-bit installation of Ubuntu 
The second tutorial explains how to manually install the .deb packages after wgetting them from the repository. It was going well until I ran sudo pecl install oci8, and received the following error:
/usr/bin/ld: skipping incompatible /usr/lib/oracle/xe/app/oracle/product/10.2.0/client/lib/libclntsh.so when searching for -lclntsh
/usr/bin/ld: cannot find -lclntsh
I cannot find any information about why this doesn’t work, but I imagine it is because that clntsh library is for version 10.2.0 of the client and maybe oci8 expects something newer?
My only solution is that I need to download the latest client and see if that works. While writing this post, it dawned on me that it’s a bit strange that the Oracle sign on page was not working, so I tried it in a different browser. It turns out that the Oracle sign on page is incompatible with Opera, which is a shame.
I started following “something” but realised it was just making things more complicated and decided to just follow the instructions on the Ubuntu PHP Oracle page. And it works! Now I can connect PHP to Oracle.
Lessons Learned
- Just follow the instructions on https://help.ubuntu.com/community/PHPOracle.
- Don’t use Opera to download from the oracle site, because their single sign on page does not work.
Audio proceedings
Following my post from Connected Past a few weeks ago I have been thinking more about different kinds of conference proceedings. Reading your paper aloud gives you an audio, video and “presentation” representation of your work. Each of these gives you a different way to experience the conference. You can read the conference, listen to the conference, watch the conference and admire/distill(?) the conference. You can also mix and match if you so chose. Have the audio on while you follow reading the paper or watch the video with the slide deck transitioning in sync (maybe one on each monitor).
All this thinking set me thinking… Say we only have paper proceedings from a conference, what parts of this puzzle can we put back together. We can probably reclaim the slides used if we ask nicely. But even if we have a video of a person giving a presentation unless they read their paper aloud we will not have an audio transcode. I took this idea and ran with it. We have text to speech programs I wonder if we can create an audio reading of the paper. A little googling lead me to espeak a open text to speech tool for linux. It has simple interface you can copy text into and it will read and more importantly to me it has a brilliant command line tool.
With a one line bash script you can go from a PDF file (the evil mainstay of academic conference formats) into an mp3 which you can pop on your iPod and listen to on the way home. Simply open bash and type the following:
pdftotext input.pdf -| espeak --stdout | lame - output.mp3
pdftotext extracts the text, espeak turns it into audio and lame encodes the audio as mp3.
This is not going to work with everything. PDF is an unpredictable format and you may get all kinds of nonsense from pdftotext but it does work in a majority of cases. Also you are probably going to struggle with equation heavy formats like chemistry and maths. For a one liner its not a bad start.
Then I moved on to what I thought would be a much more challenging problem. The much more modern and appropriate HTML document. A far better medium to publish scholarly work but has the challenge that it usually has the navigation built into the format. These navigational elements are read aloud which spoils the audio. No sooner had I expressed to the problem to Sina Samangooei and John Hare (the multimedia boys) and I had an instant solution. They work on multimedia library called OpenImaj. As part of there work they discovered this tool Readabilty which removed visual complications from HTML. They adapted the source into their library and built it into a comand line tool called WebTools. You can get the source for WebTools from there project page or simply download the JAR which I have uploaded to EdShare. With this tool the process for HTML is as simple as it was for PDF. It would also be great for making printable versions of web pages.
java -jar WebTools.jar Reader -text http://www.bbc.co.uk/news/uk-england-hampshire-17350103 | espeak --stdout | lame - ouput.mp3
Now if you ran these tools over a set of conference proceedings you would have created audio conference proceedings to play on your MP3 player. It was so simple I am already wondering why there isn’t an EPrints Plugin which does it.
Privacy by Indolence
I know it doesn’t have the same dactylic rhyme as “security through obscurity”, but the discussion we led at #cetis12 really drove home to me the fact that a lot of people rely on the laziness of others to remain private.
It turns out that a lot of people give away more data in reality than they say they would if you asked them. It’s called the privacy paradox. Many of the people who claim they want to remain private still post all their photos on Facebook and use Google for search, despite it being well known that they both harvest and hoard immense amounts personal data.
Some of this can be put down to people not knowing or reflecting on how things work behind the scenes, but I think there’s an element of expected behaviour from other people and relying on their laziness to keep our data private.
I have reached this conclusion by the reaction people have to making access to data easier. That is one of the fundamental aims of the Southampton Student Dashboard after all. Even though the data is accessible in one way or another (whether it is virtually trudging through Banner Self-Service or physically trudging down to student services to view the paper copy of a student record), people immediately raise privacy concerns as soon as you present an accessible interface to it.
An example of this came up in the discussion. One group were asked what directory information should be available on the University intranet, and the issue of photos was hit upon. When we ask the potential users of the Dashboard what information would be useful to them, photos are always high on their list. However, one of our participants countered with something along the lines of: “if students want others to see what they look like, they put photos on Facebook, just go look there”.
Well immediately that begs the question, if it’s already openly available, why make someone go to more effort to see your photo, unless you are hoping they will just give up and not bother?
PANFeed feature roll out
Some of you may be wondering what happened to PANFeed Journals and Issues that we mentioned back in November. Well we have been quietly working away on them. Today we released the newest PANFeed. New features include user accounts, and with user accounts you can create Journals and Issues. We have done a fair bit of testing and trying out of different models and broadly the model has been well received. Journals allow you to take a much more hands off approach to managing your news where as issues give you a much greater level of control. I’d like to thank William Nixon, Les Carr and the students from the Web Science DTC who have been playing about with it and coming up with some use cases.
Another side affect of get all of this sorted is our Google Code is finally upto date with the latest source. Sorry for not pushing for long I promise to be better moving forward. PANFeed is not feature complete (as if anything every could be) but its got a lot of tools and tricks that we think will be useful moving forward. A few things on my personal to do list are:
- Add a public and private element to Journals and Issues, so that you can keep the bits you are working on hidden away.
- Add the ability to delete journals and issues.
- Do make a release of the new version of PANFeed which is trivial to install.
- Make a tutorial video explaining how Journals and Issues work and talking about the use cases.
Please pop along and try out the new PANFeed and let us know if you have any problems.
RedFeather Architecture
One of the big selling points of RedFeather is how light weight it is. The intention is that a base install of RedFeather will be a single .php file which can be dropped into almost any web space to provide quick and straight forward access to digital resources. This objective presents a number of problems which require us to think carefully about RedFeathers arhitecture.
The tool must be a single file and it must run on almost any php install but it must be flexible enough that functionaliy can be trivally extended or over written. A fairly simple way to achieve this goal might be make RedFeather one “Class” and modifications can inherit from it. This is neither simple enough for our tastes, particularly when you consider running multiple extentions, but it also breaks our rule about running anywhere. PHP is a fairly ill considered language has only had object orientation since version 5. Since many servers run PHP 4 the software can not be object oriented.
RedFeather has a very basic but powerful aritecture. It allows you to define pages as a list of functions to be called in order. Each of these functions is then declared and registered in a function map. As each of the functions for the page executes they access a global variables hash and contribute to the proceedural building of a “page” which is then returned when all of the functions have executed. Ironically this model is not far from how many languages object model actually works.
This structure has a number of useful properties. You can easily insert a function into the list of functions which build the page. You can added new pages and reuse functions used to build other pages. Finally if you want to completely change what a function does you can write a new function and change the reference in the function map to point to your function rather than the one initially declared. Thus you can easily overwrite functionality and extend the functionality of RedFeather in a flexible way which is reasonably easy to understand. It is debatable whether this model would scale for larger code bases but the light weight nature of RedFeather means this hopefully will not be an issue.
Why you would read a paper…
I began writing this post at the Connected Past conference, which being someone not burdened with any real understanding of humanities, was astonishingly interesting to me. However this post is not really on the subject of networks. It is on the subject of scholarly discourse.
Until Connected Past I have only heard about and never witnessed, what in computer science, would be considered a phenomenon but in humanities, I am told, is much more common. I watched a person give a conference presentation by standing up and reading their conference paper. When I have heard about this in the past reaction has been to dismiss it as a largely valueless and disengaging enterprise. Seeing it live really set me thinking in a number of ways I had not bothered to previously.
Let us suppose that the purpose of a conference is to disseminate your work. You put days of effort into preparing that paper and there is a very real danger that it will never be read. The data deluge is so vast that most people would not have time to read every paper from a single conference much less from all the conferences. The purpose of a presentation might be argued to be a summary of the work carried out. A paper is summary of your work already, but now you are summarizing that summary. The idea that a person could read their paper allowed in presentation time demonstrates that their work does not need further distillation.
Perhaps you might say the aim was to simplify the ideas. If you feel that, at an academic conference with an audience of academic discipline peers, you need to simplify your paper then you NEED to simplify it for everyone. Maybe the language you wrote your paper in does not transfer well to the spoken word. That undoubtedly means your paper does not read well.
From the plus side if someone reads you their paper you don’t need to read it until you refer back to it. Frequently conferences presentations are being captured on video. This means you have created is a multimedia version of your paper. I might start doing this because it is clearly of benefit. I have spent a lot of time looking at replacements to academic papers but until now my ideas have always been based on text. Imagine if your iPod on the walk to work was reading you the academic papers from a conference.
In conclusion I do not think that this is one presentation format to rule them all, but I think it serves its function as well if not better than some of the alternatives. I would definitely tell people like myself to shut up and think about the real practical of elements of the academic processes before dismissing an unfamiliar style out of xenophobia.
The first page of Google didn’t yield any supporting blog material for my argument but I did happen upon this interesting article: http://thenoisychannel.com/2009/08/02/are-academic-conferences-broken-can-we-fix-them/ I think we have to go back to the drawing board of the academic model and build something which actually achieves our goals. As I constantly harp on the WAIS seminar series should be a seminar series not a lecture series…