Showing posts with label browse. Show all posts
Showing posts with label browse. Show all posts

Tuesday, 11 December 2007

Multi-lingualism and the masses

Multi-lingualism, and the provision of multi-lingual services, is one of those problems that just keeps on giving. Like digging a hole in sand which just keeps filling with water as fast as you can shovel it out again, or the loose thread which unravels your clothes when you pull on it. I remember being told, back at the start, that multi-lingualism was a solved problem; that i18n allowed us to keep our language separate from our application.

When the first major work was done on DSpace to convert the UI away from being strictly UK to being internationalised, there was great cause for celebration. This initial step was extremely large, and DSpace has reaped the benefits of having an internationalised UI, with translations into 19 languages at time of writing. It's also helped me, among others, understand where else we might want to go with the internationalisation of the platform, and what the issues are. This post is designed to allow me to enumerate the issues that I've so far come up against or across, to suggest some directions where possible, but mostly just to help organise thoughts.

So lets start with the UI. It turns out that there are a couple of questions which immediately come to the fore once you have a basically international interface. The first is whether display semantics should be embedded in your international tags. My gut reaction was, of course, no ... but, suppose, for example, emphasised text needs to be done differently in different locales? The second is in the granularity of the language tags, and the way that they appear on the page. Suppose it is better in one language to reverse the order of two distinct tags, to dispense with one altogether, or to add additional ones? All of these require modifications in the pages which call the language specific messages, not in the messages themselves. Is there a technical solution to these problems? (I don't know, by the way, but I'm open to suggestion).

We also have the problem of wholesale documentation. User and Administrator help, and system documentation. Not only are they vast, but they are often changing, and maintaining many versions of them is a serious undertaking. It seems inappropriate to use i18n tagging to do documentation, so a different approach is necessary. The idea of the "language pack" would be to include not only custom i18n tags, but also language specific documentation, and all of the other things that I'm going to waffle about below.

Something else happens in the UI which is nothing to do with the page layout. Data is displayed. It is not uncommon to see DSpace instances with hacked attempts at creating multi-lingual application data such as Community and Collection structures, because the tools simply don't yet exist to manage them properly. For example:

https://gupea.ub.gu.se/dspace/community-list

where the English and Swedish terms are included in the single field for the benefit of their national and international readership.

Capturing all data in a multi-lingual way is very very hard, mostly because of the work involved. But DSpace should be offering multi-lingual administrator controlled data such as Communities and Collections, and at least offering the possibility of multi-lingual items. The application challenges here are to:


  • Capture the data in multiple languages

  • Store the data in multiple languages

  • Offer administrator tools for adding translations (automated?)

  • Disseminate in the correct language.


Dissemination in the correct language ought not to be too much hassle through the UI (and DSpace already offers tools to switch UI language), but I wonder how much of a difficulty this would be for packaging? Or other types of interoperability? Do we need to start adding language qualifiers to everything? And what happens if the language you are interested in isn't available, or is only partial for what you are looking at? Defining a fall-back chain shouldn't be too hard, but perhaps that fall-back chain is user specific; suppose I'm English, but I also understand German and French: I don't want the application to fall back from English to Russian, for example.

This post was actually motivated by a discussion I have been having about multi-lingual taxonomies, and using URIs to store the vocabulary terms, instead of the terms themselves. In this particular space, URIs are a good solution, because they are tied to a specific, recognised wording. It does place a burden on the UI, though, to be able to hide the URI from the user during deposit and dissemination.

But the same approach could, in theory, be used to offer multi-lingual browse and search results across an entire database. Imagine: each indexable field is collected in its many languages, a single (internal) URI is assigned to that cluster of terms, and that URI is stored instead of the value. With a lot of computational effort you could produce a map of URIs to all the same terms in all the different languages in the database and their corresponding digital objects, which you could offer to your users through search or browse interfaces (I'd not like to be the one to have to implement this, and iron out the wrinkles which I'm blatantly overlooking here).

There are many other corner areas of applications which include language-specifics, and it's going to take me a while to gather the list of what they are. Here are a few which aren't covered by the above:

  • system configuration

  • code exceptions and errors

  • application email notifications


A second major step has been taken for DSpace 1.5 with regard to multi-lingualism, in the form of Claudia Jürgen's work on submission configuraton, help files, emails and front page news. The natural progression would be onto multi-lingual application metadata, and from there the stars ...

Thursday, 25 October 2007

DSpace 1.5 Alpha with experimental binary distribution

The DSpace 1.5 Alpha has now been released and we encourage you to download this exciting new release of DSpace and try it out.

There are big changes in this code base, both in terms of functionality and organisation. First, we are now using Maven to manage our build process, and have carved the application into a set of core modules which can be used to assemble your desired DSpace instance. For example, the JSP UI and the Manakin UI are now available as separate UI modules, and you may build either or both of these. We are taking an important step down the road, here, to allowing for community developments to be more easily created, and also more easily shared. You should be able, with a little tinkering, to provide separate code packages which can be dropped in alongside the dspace core modules, and built along with them. There are many stages to go through before this process is complete or perfect, so we encourage you to try out this new mechanism, and to let us know how you get on, or what changes you would make. Oh, and please do share your modules with the community! Props to Mark Diggory and the MIT guys for this restructuring work.

The second big and most exciting thing is that Manakin is now part of our standard distribution, and we want to see it taking over from the JSP UI over the next few major releases. A big hand for Scott Phillips and the Texas A&M guys for getting this code into the distribution; they have worked really hard.

In addition to this, we have an Event System which should help us start to decouple tightly integrated parts of the repository, from Richard Rodgers and the guys at MIT. Browsing is now done with a heavily configurable system written initially by myself, but with significant assistance from Graham Triggs at BioMed Central. Tim Donohue's much desired Configurable Submission system is now integrated with both JSP and Manakin interfaces and is part of the release too.

Further to this we have a bunch of other functionality including: IP Authentication, better metadata and schema registry import, move items from one collection to another, metadata export, configurable multilingualism support, Google and html sitemap generator, Community and Sub-Communities as OAI Sets, and Item metadata in XHTML head <meta> elements.

All in all, a good looking release. There will be a testathon organised shortly which will be announced on the mailing lists, so that we can run this up to beta and then into final release as soon as possible. There's lots to test, so please lend a hand.

We are also experimenting with a binary release, which can be downloaded from the same page as the source release. We are interested in how people get on with this, so let us know on the mailing lists.

Come and get it:

http://sourceforge.net/project/showfiles.php?group_id=19984

Tuesday, 17 April 2007

Configurable Browse System released

Well, things have been a little quiet on here, what with my extended easter break. But now I'm back in the office and getting on top of things again. There's a few things to update on, which I will be doing over the next couple of days. The most exciting thing today is that I have finally finished the release candidate code for the new Browse system for DSpace. If you are a DSpace user, please check it out at:

https://sourceforge.net/tracker/index.php?func=detail&aid=1702233&group_id=19984&atid=319984

I have been using the core of this for some time, so it is should be stable. Your feedback would be welcome.

Thursday, 22 March 2007

Crawling like Ants

During experiments yesterday I discovered that running java processes from inside the Ant build tool can have unforseen performance issues. I had written an Ant task to build the browse indices for my DSpace system. This involves producing 9 separete indices for around 80,000 records, and is not a rapid process at the best of times. Previous executions of this code have yielded index rates of approximately 10 - 15 items per second, which I was pretty happy with. Running it in Ant, though, dropped my performance right down to a low of 1 item every 2 seconds! After this had run for several hours I killed it, and tried it again directly from the command line; up came the performance again to usual standard.

So, what is going on? Here are some details:

- while indexing in Ant, the box was under almost no load - no physical memory shortages, disk io bottlenecks, etc.

- I toyed with the idea that memory allocation to the JVM was the problem, but I've seen the indexer run with different memory allocations, and it has so far never caused a speed problem (just OutOfMemory errors)

Answers on a postcard. Or in a comment.

Tuesday, 19 December 2006

Calgary Rejects DSpace for E-Theses Archives

The Rejection of D-Space : Selecting Theses Database Software at the University of Calgary Archives

This article outlines reasons that the University of Calgary Archives chose not to implement DSpace to manage their e-theses, although they are still using it for the Institutional Repository system.

I'd like to include some responses to the significan issues that Calgary encountered:


  • Searching Issues: I think that the main problem here is a lack of information about the customisations available in both the search and the browse. The existing browse has a very primitive customisation capability, but the search indexes are extremely flexible, and probably the addition of search.index.<x> = dc.date.accessioned would be sufficient to construct accurate searches or reports on specific years. The admission of responsibility on the DSpace part is that the search interface is not the most flexible, and it is not possible to construct searches like this without knowing exactly what you are doing. This is a very serious issue, because the report cites lack of sufficient search indices as a major concern, and yet a quick peek into the dspace.cfg file, and a quick tweak of search/advanced.jsp and all the problems are solved.


  • Browse by date: just to blow my own trumpet for a moment, when the browse code I've been working on is finished, it will be possible to index by date, and browse only items within a specific period. So if date.submitted = 1994, then you can browse on all date.submitted where it is 1994 and so on


  • Counting results: using the mechanisms above it would be possible to get the results counted correctly. Even if not, recourse back to generating SQL queries to do the counts would be much more desireable than counting by hand, and since our code base is open, you are free to write in the functionality


  • Cannot do X: much of the content of this article is about how the UI cannot do X (allow you to search for more than 3 terms at a time | search on the relevant fields). DSpace is an Open Source product, where words like "cannot" should not be used unless you really have looked into it. The underlying search engine can do all of the things required for Calgary, and all it requires is the alteration of the UI to support it


  • Reporting Issued: as has already been noted at time of writing on the DSpace lists, DSpace is not a reporting tool. I understand Calgary's pain here, as it is part of my remit to report on the content and activity of our repository. I will be using a combination of the log file analysis, the web server logs, and potentially the Minho stats add-on. I would welcome a suite of reporting tools for the platform, though


  • Sorting search results: That DSpace can't is a complete nuisance, and I agree that it should be able to do so. Lucene, which is the search engine upon which DSpace relies for this functionality, does support result searching, so if anyone wants to have a go at adding in the feature, I expect you would be very popular


  • Public and Private Display: This is also a potential shortcoming of DSpace, and was certainly not a design goal in the initial case. DSpace was originally intended to help you achieve open access, and so does not do so well with the ideas of public and private views. To fix this here at Imperial we have one public repository and X private repositories which deal content to the public one on demand (and yes, one of those private repositories is an under-construction e-theses repository built on DSpace).


  • scalability: I feel that Calgary didn't do their research regarding scalability here. They worry that adding 600 new items annually might be a problem. Cambridge have 200,000 records in their public repository, and we have 75,000 records in our private repository, and while there are scalability bumps, they are being ironed out, and they don't show up until you get into the tens of thousands of records at all. I blame this on the over cited (so I won't) DSpace Scalability Issues page on the wiki being people's only source of information.




So what can we, as the DSpace community, learn from this. The first thing is probably about documentation - we are very good at documentation, but sometimes it can be hard to find what you are looking for. Could we do more, and if so what?

The second is about customisability of our UI. Manakin will hopefully lay to rest many of the problems that we come up against with our UI customisations, but we should also bear in mind that library administrators want graphical interfaces to modify their configuration in all senses. I can give you a concrete example of where having our config defined through the UI would be useful: At Imperial College if we want to change the configuration and restart the application server to pick up the changes, we need to go through an official "Change Request" process. If this could be done through the UI, though, this would become an administrative task, and would not require the extra bureaucracy! In addition, it will make it easier for non-technical folks to understand what options are available to them.

Third is about the nature of Open Source. DSpace has many known problems or discrepencies between what the UI will allow and what the underlying application will actually support. The DSpace core is much more powerful than the UI would have you believe, and those of us who spend most of our time "under the hood" can testify to the things that you can make it do if you know what you are doing. The problem at Calgary was that they didn't appear to understand that in order to make the system work in their exact niche, it was going to require some modification. This is a different issue, in my mind, than not having the resources to undertake said modifications.

Nonetheless, if WebGencat meets their needs, and DSpace does not, then that is a success for the diversity of software products available and the evaluation process in this part of the market. We (the DSpace community) need to learn from the feedback in the report, and hopefully use it to make our system better.

Friday, 8 December 2006

Sorting in databases

Discovered via a circuitous route, Jim Downing notes that Dorothea Salo has a great tip for fixing sort ordering in the DSpace browse. Since I'm working on this feature as we speak, it's important for me to be able to take this on board. In fact, I have the following feature planned:

Allow each field to request a Normaliser for its entry into the sort_value column of the browse system. Using the PluginManager for DSpace, this might look like this:


String myValue = "some value to be normalised";
String myLang = "en"; // this is the language I want to normalise into
Normaliser myNormaliser = (Normaliser) PluginManager.getNamedPlugin(Normaliser.class, myLang);
myValue = myNormaliser.normalise(myValue);


our configuration for this would then probably just be something like the following:


plugin.named.org.dspace.browse.Normaliser = \
org.dspace.browse.EnglishNormaliser = en, \
org.dspace.browse.NorwegianNormaliser = no


and so forth. Then, the way your normaliser works would be up to you, and perhaps for Dorothea's example, you need to just maintain a mapping file of unicode values and their target English representation.

Wednesday, 29 November 2006

DSpace Browse Code Redevelopment

Here at Imperial we have a 70,000 strong set of records for academic publications that we have to deal with. The current browse code for DSpace is pretty inflexible and hides some scary scalability problems. For example, if you have 3000 records all produced by the same author, and you attempt to browse all the publications by that author, it will instantiate an Item object on each of those 3000 items and display it to the user. This can Cause Things To Be Slow.

A long while back I wrote some code which allowed you to specify which metadata fields you wanted to bind to the existing 3 browse indices (later increased to 4 by the addition of a subject browse). As an engineer, the idea that you couldn't just define your indices in real time, or if not real time at least in configuration, meant that I simultaneously started to reconsider rewriting the browse system. To that end, I produced an initial prototype of a generalised browse patch, which was attached to the patch tracker as number #1480998.

The consequence of this second development was that the author browse problem could be quickly discovered in other contexts, and, more problematically, more likely ones. For example, we store workflow information about our 70,000 records, and at the very start, when the first data import has completed, we have every one of those records with the same status ("new"). In this case, if you select our "Browse by Item Status" -> "new" option configured using the patch, the system attempts to display to you 70,000 instantiated Items. I don't know anyone who has yet waited to see if the page will ever display.

A second problem was discovered while attempting to fix the first: that paging the results of a "second level browse"* was impossible because the focus of the browse and the value of the browse are conflated in the code, so that it was simply impossible to apply pagination to a specific value browse (e.g. browse by status where status = new) with the existing code. A new understanding of the browse process was needed.

This is what has led us to redevelop the browse code to fix both of these issues. The development process is being live documented on the DSpace Wiki, at the URL:

http://wiki.dspace.org/index.php/DynamicBrowsePrototype

Once finished, this code will be made available to the community via the patch tracker. Keep an eye on the wiki to watch its progress.