Friday, June 30

Localization coordination for Debian #3

This time the weekly report is late, sorry about that. I spent the better part of the week without access to the internet.

I did have my computer with me, and I have worked a bit on the Pootle backend API, which was received without major complaints on the Pootle mailing list. There were some very slight changes to the interfaces. Most importantly I whipped up a simple proof-of-concept implementation of the interfaces. That revealed a few more small problems, but now I am confident that the interfaces are consistent and can actually be implemented. This demo implementation is not persistent, but it might be useful as a base for other implementations and in tests, or it could be trivially made persistent with use of pickle.

The current API and the implementation are in the Pootle CVS repository (see here).

Next, I will attempt to wrap .po file classes that Pootle currently has. Implementing basic functionality should not be very difficult there, especially with recent changes by David Fraser.

Tuesday, June 20

Localization coordination for Debian #2

I sent a new revision of the suggested translation storage API to the mailing list, addressing all the shortcomings that have been pointed out. Hopefully it will not change much any more and I can start working on an implementation this week.

My plan is to first produce a very simple pickle-based implementation of the API. This should be relatively quick to build and would highlight the weak points of the API. I think that this can be finished this week. After that (and possibly revisions to the API) comes the important part: writing a nice wrapper for the existing pofile class. This should not take too long either, another week at most (especially since my exams would already be over).

When a .po-based implementation is in place, the fun starts. I'd then like to try to have another application that concurrently uses Pootle's backend storage (currently po-based). Another week of work.

Tuesday, June 13

Localization coordination for Debian #1

I have been working on an integrated l10n infrastructure for Debian. Instead of starting from scratch, the Wordforge project was chosen to be used as the base. Currently Wordforge has a toolkit for various l10n operations as well as a web frontend Pootle that uses this toolkit. My job is to adapt these tools to Debian needs.

I see three major areas of my future work in Wordforge:

  • scalability: importing all translations of all packages in Debian into Wordforge as it is would require a very powerful computer. I believe that a planned transition to a relational database as the backend of Wordforge (instead of plain old files) will help immensely here.
  • frontends: there is only one frontend to the system, Pootle. Debian will need an e-mail interface, an XML-RPC interface, a Subversion interface and possibly others in addition to the web interface. This is more difficult than it sounds because Pootle is intertwined with the backend. Work is underway to define a clear API for the backend that could be used by various clients.
  • process: Debian translators have strict translation review and ownership processes. These would have to be incorporated into Pootle.

A (to me almost distressingly) large amount of discussions took place on the debian-i18n and Wordforge mailing lists on these topics and more as I dug into Wordforge to better understand the current situtation and plans of other developers. After the initial communication peak, now things are really starting to roll. Here's what we have now:

  • A general concensus for a move in Wordforge towards a relational database. This took quite a bit of convincing ;)
  • Agreement on the ideas of a new backend API
  • A sketch (in code) of the new API

I posted the sketch of the API to the Pootle mailing list. There was little opposition and mostly constructive remarks. Unless a disagreement pops up, I would expect the API design to be finished by next week.

My longer term plans:

  • write an implementation for the new API (a week)
  • cover the current file-based backend under the API (difficult to estimate)
  • migrate Pootle to use the new backend (difficult to estimate)
  • write a new frontend or two: e-mail, XML-RPC (a week)
  • write a backend based on a relational database (a week)

One thing that is still keeping me down a is a couple of exams due in a week. After that I should have much more time to work on this project.