The DCC Alliance (not to be confused with the DCC Alliance, which is entirely unaffiliated with the former. But it's a recursive acronym, so there's NO TRADEMARK ISSUE) aim to produce a distribution which is entirely binary compatible with Sarge. A laudable aim. Sadly, there's a bit of a problem.

OpenOffice.org 2.0 was released this week. In common with previous versions, it's a horrid mixture of C++, Java and assembler. It's the Java that's the problem, of course. To compile it, you either need Sun's ridiculously non-free Java, or you can use gcj. That's gcj 4.0, of course. Which can be installed in parallel with gcc 3.3, so that's not a problem. Except. gcj 4.0 wants the libgcc from gcc 4.0 (unsurprisingly), which has the same SONAME as the libgcc from 3.3 (correct behaviour - code built against libgcc from 3.3 will run fine with libgcc from 4.0). However, libgcc from 4.0 adds some extra symbols - as a result, code built against libgcc from 4.0 will not necessarily run on systems with libgcc from 3.3.

Or, in other words, shipping libgcc from gcc 4.0 will result in a system that will build binaries that can't be installed on machines running plain Sarge.

So, there's a bit of a dilemma. Either

• Fail to support OpenOffice.org 2.0


• Only support OpenOffice.org 2.0 if non-free Java is used


• Break binary compatibility with Sarge


• Do something really quite nasty

The DCC Alliance want to build a distribution base that's binary compatible with Sarge. It's an entirely laudable aim, and (regardless of any impression I may have given in the past) I hope it's successful. But. That level of binary compatibility inherently compromises your ability to use new software. To begin with, you can work around that - backport code to older versions of libraries, include local copies, do static linking, that sort of thing. Over time, it gets harder.

Optimistically, Etch will be released in December 2006. If we assume that DCC releases occur at roughly the same rate as Debian ones, we're looking at 18 months until we get a DCC based on etch.

In 18 months time, is it really going to be possible to build a useful modern desktop system that's binary compatible with Sarge without it being an utterly unmaintainable pile of ugly hacks? Even after 5, we're seeing pain.

There's a reason that derivative distributions tend to diverge from the original project. It's because it's really quite remarkably difficult to maintain sanity, technical correctness and not change any of the underlying structure. I'd like to see DCCA succeed in doing so, and I do admire them for not just giving up in exasperation already.

This are some random thoughts I posted to the G-Wrap development mailing list regarding creating bindings for C libraries for Scheme. Although partly G-Wrap specific, it also might be of interest to other Scheme hackers. I’m not at all convinced my effort to make G-Wrap support Scheme 48
makes much sense at all, for these reasons:

• Most of G-Wraps complexity stems from C code generation, which is
  not necessary with a Scheme-level FFI, such as Scheme 48 and PLT
  Scheme provide. It seems a different, more simple tool, with the
  different features would be much more suitable: With a Scheme-level FFI, you can conviniently bind a given C API
  by writing Scheme code; it seems backwards to use a code
  generator, as you have one in Scheme itself in the form of
  macros. The problem is a different one: extracting certain
  information from the C API that is not (convieniently) available
  without invoking a compiler, such as the values of C macros and
  enumerations. With the code-generation approach, this knowledge is
  compiled into wrapper functions (and thus hidden away). With a
  tool I envision, that knowledge would be _extracted_ at the tools
  run time, by generating simple C programs that print those values
  in S-expression form, invoking the compiler on the C code, and
  running the resulting executable. This is quite different from
  what G-Wrap does, and retrofitting such functionality into G-Wrap
  would make it even more complex. I can really recommend reading the paper about the PLT FFI, linked
  from the CSW, to see how expressive a Scheme-Level FFI is; hiding it
  below a code generator only takes away from that.
• Now that my focus has shifted from Guile to Scheme 48, and
  portable Scheme in general, I view my rewrite using GOOPS
  ambivalently; the rewrite has certainly made G-Wrap more flexible
  and extensible, and probably given it a clearer structure,
  however, due to GOOPS’ use of keywords (while they are
  R5RS-compatible and supported by some other implementations),
  GOOPS is fundamentally non-standard, without touching the core of
  implementations that don’t provide #:foo-style keywords it isn’t
  possible to implement it on other Schemes. IMO, G-Wrap supporting
  multiple back-ends only makes sense when it also is able to run on
  these implementations, or else it probably won’t get much usage.

So in short: G-Wrap’s future looks brightest when staying a Guile
(-only) tool; a much more simple, portable C-binding tool can be
achieved by:

• Implementing a PLT-style FFI. This already goes a long way towards
  easing the work of creating bindings; I wrote a simple mysql
  binding for Scheme 48 in 135 lines of pure Scheme. Actually, the
  RTI (run time information) layer in G-Wrap can be seen as a
  half-implementation of that approach; implementing a subset of the
  PLT FFI for Guile based on that part of G-Wrap would be not very
  hard (speaking from my experience on doing the same thing for
  Scheme 48).
• Supplement that with tools that can extract the low-level C API
  information from headers, by parsing and compilation (as outlined
  above). Also G-Wrap could profit from a C header parser, as
  writing the declarations for the wrappers is quite tedious if more
  than a few functions are involved. I haven’t really looked at it,
  but scheffig is a tool that looks similiar to G-Wrap on a
  superficial level (generates C wrapper functions) and leverages
  the FCC C parser written by Mike Sperber, which probably is quite
  portable.
• The low-level API information, as extracted in the above step still
  doesn’t contain enough information for useful Scheme bindings, as
  part of the information needed for binding a C library are only
  available in its documentation, for example the semantics of memory
  allocation, for example whether a “double *” function argument in
  fact an array of a certain size, specified by another argument of
  that function, or a output argument. This information would be
  encapsulated in hand-written high-level bindings that make use of
  the automatically generated low-level bindings that result from
  header parsing.

A surprisingly high proportion of ex-UEA people stay in the area after finishing at UEA. Over 40% want to, according to the local chamber of commerce. Eventually, that number falls: with John and Brett leaving, I think I can now count on one hand those from my Norwich years (1994-1998) who I know are still here. Most left some time ago. Why? Small place syndrome? Underpaid work? Both? Possibly. It feels like only in Norfolk could the train station start to expand its car park to cope with demand and the same week most train services to it are cancelled because a Cambridgeshire farmer drove onto the single line stretch, was killed and it takes at least a day for access and safety checks in this sparsely-populated area. From the BBC's picture, the unit involved was one of the commemorative King's Lynn "picture trains". You seldom hear what happens to the damaged trains and injured drivers. I guess the railways and the media doesn't like to worry passengers. Even the Potter's Bar investigation ending only got brief mentions that I saw. Also at the train station, local police put out a picture of people they would "like to interview" about the spate of recent bike thefts. Possibly as a result, they've charged one man. Someone I know had a bike nicked, which meant a long walk to/from work until it was replaced. Very annoying. The sort of petty bike vandalism/theft which annoyed savs is also on the increase here again. I'd've expected nicked bikes to sell better in summer, but maybe the local crims are thick or there are more easy-to-nick bikes in September. At least it's not Fakenham, (which is one of the most boring places on earth, you may remember - original source ) where the headline story is that the kerbs are too high. I'm sorry someone was hurt, but kerbs here seem tiny compared to the ones in Northamptonshire. Probably they've all been lowered for safety there too now. As a result of adding Dave's blog to Planet ALUG, I noticed BritBlog for the first time. I spent a while browsing the other Norfolk-based blogs on it one evening. Unsurprisingly, I knew about most of the ones I found interesting already, apart from Ztroller who links to me... erm, why? Does he read this? Most listings are from blogspot and I still won't add Atom support to my blogging software - I want to read, not edit, so Atom is mostly extra cache filler. I only added Really Simple Syndication as well as RDF Site Summary because it was fairly cheap to do and I didn't know about the obvious way to get RSS 1 from Wordpress. Finally, in local(ish) concerns, Northern Ireland, from Noodles' emptiness:

"while I'm ranting, why is the adjective for someone from the UK "British"? Britain doesn't cover all of the UK. I wasn't born in Britain yet I'm British. Can't I be UKish or something?"

I'd hate to be called UKish. I don't have any particular affection for this Kingdom's political boundaries. If the UK ended tomorrow, would anyone besides its rulers mourn? I'll not thank you if you call me British. I'm English, a midlander and Towcestrian. British nationality is a side-effect. (And why is it so hard to get .gb domains anyway?) It's odd that there's such argument over England's anthem. So there is imagery or irony involved in Jerusalem, depending how you want to view it: who cares? It's rousing (unlike the UK dirge) and mentions England past. Yikes, I've just discovered I'm agreeing with Billy Bragg of all people. As for the UK, why don't we work together with others when we agree and work independently when we don't agree? Unfortunately, few politicians advocate English self-rule, apart from racist bigots and English imperialists. The really depressing thing is that those sort of people would probably easily get a majority in any English legislature, if backed by the mess media. Maybe Britain is diverse enough that it balances the extreme English... diverse we are or de verse it gets... (ouch)

Breaking radio silence to complain about something both trivial and technical, so it’s probably best if everyone skips this post. Unless you write a CD ripper or audio tagger. Then please read this post, because I’m going to explain why you’re wrong. (Someone emailed me about why Quod Libet acts this way, and I figured I’d make my answer public, with the hope it helps things.) History
Decades ago, before there was Ogg Vorbis, people used an obsolete standard called MP3, and tagged it with something called ID3 (in particular, ID3v2). One of the possible tags was TRCK, for the track number. It was stored as a string in “x/y” format, for track number x out of y total tracks. Perhaps this could be improved upon; maybe not (I’ll make a case for not later). Regardless, that’s how hundreds of thousands, if not millions, of files were tagged. Ogg Vorbis Comments
These days we have something better — Ogg Vorbis and its tagging format. Vorbis specified a tag called tracknumber, analogous to TRCK.

TRACKNUMBER: The track number of this piece if part of a specific larger collection or album

Now, this is a bit ambiguous. In particular, TRCK says how you should store the total number of tracks, and the Vorbis comment specification doesn’t. A strict reading indicates you can’t, but then the same standard is designed to be particularly loose about the data stored in the tags. So a lot of programs, including really popular ones, just kept their ID3 format and wrote tracknumber=x/y. Everyone was happy. Then someone — I wish I knew who, so I could write this to them personally — decided trying to parse the track number in this format was too hard, and so decided they would make a tracktotal tag that stored, as a single number, the number of tracks. Whoever Did This Is Wrong
Whoever decided to do this was pretty dumb. There’s a number of false assumptions here, roughly in decreasing order of annoyance:

• When you make a new standard, people won’t follow it (assuming otherwise is one of the stupidest design decisions possible). Lots of programs still wrote the x/y format. Quod Libet still does. I think it’s a better format. So now all that happens is everyone needs to implement both formats.
• When you make a new standard, people won’t follow it (as bad as it is, they made this mistake twice). Anything that does Vorbis tags probably does ID3 tags, and ID3 isn’t going away any time soon. So you still need the x/y parser no matter what.
• When you make a new standard, people get it wrong. So now we all need to support totaltracks, tracktotal, and x/y.
• Every other new tagging standard uses something much closer to x/y. Apple’s MP4 metadata, for example, uses two bytes in a single trck value. APEv2 uses Track=x/y. This is pointless differentiation.
• x/y is not hard to parse. There’s a horrible function called atoi that does it, and a lot of better ones.
• Using a simple numeric string still needs atoi and friends, because you don’t want “2″ to sort after “11″.
• You’re just trading parsing for reconstruction later. Quod Libet displays “Track [tracknumber]” which gets it right every time. Otherwise you have two strings “Track [tracknumber]” and “Track [tracknumber] of [tracktotal]” (no, you can’t just have “of [tracktotal]”, that ruins i18n).
• Users would rather enter a single “tracknumber=1/21″ than “tracknumber=1; tracktotal=21″.
• All else being equal, tracknumber=x/y is shorter. Maybe not a big deal, until we see a proliferation of discnumber (requiring disctotal, and totaldiscs), partnumber (requiring parttotal, and totalparts), and …

The result is that every program still needs to understand x/y — even if every Vorbis file used the new format — and the new format, and also needs to do the work to construct track numbers in the new format, assuming it wants to use them. That’s why Quod Libet converts everything to x/y format. I urge authors of tagging applications and CD rippers to abandon stupid standards. Instead, you should be spending time fixing your ID3v2 readers and writers, because they all suck too. P.S.
If anyone knows what program is putting ISO-8859-1 values into Vorbis tags, please let me know. I have spiked cluebat for you. A Summary of Other Things
I moved into a new apartment building next door to my old one, owned by the same student co-op, so it doesn’t actually seem like I moved at all. School started and is going well. I saw DOOM earlier this week for free, and enjoyed it. I’ve learned a lot about Python i18n over the past few months and am writing a brief howto explaining how to do it properly.

Two new packages this week in emacs-snapshot: the first is savehist.el, a package to save minibuffer histories (grep, compile, shell command, M-x, etc) between sessions; the other is rcirc.el, a spartan IRC client which is noteworthy because it's the first IRC client to be shipped as part of Emacs. The more advanced ERC is to be installed at some later time, for now M-x irc points to rcirc.

Get it from your nearest mirror in about 24 hours, I missed tonight's dinstall by a few minutes (uploading 57M of packages takes some time).

Frederico Oliveira talks about some interesting issues regarding the information overload most of us are experiencing. He unsubscribed from several RSS feeds in order to cut down the mass of information. I'm goint to do the same thing, too. My first step was to reduce the amount of daily email, though. I have just finished unsubscribing from 16 mailing lists which I don't really read very often (this automatically reduces the amount of spam I get, too). I'm left with ca. 80 mailing lists now. I'll probably remove some more and concentrate on those which I really need and/or read regularly. The next step is to unsubscribe from several RSS feeds, but that's not that much of an issue. I find tracking RSS feeds easier and more manageable than tracking mailinglists (not sure why). For the statistics freaks, I currently subscribe to ca. 320 feeds, but I read way more of them regularly than I do with mailing lists...

The Internet Advertising Bureau thinks the UK spend could be over a billion for the first time. It's now 5.8% of the national advertising spend and is growing at a pretty remarkable rate. Is Christmas coming early for online? OSCommerce - the future will be templated. We're doing more OSCommerce work and 2.2 MS2 is a fairly typical PHP application, with some structure, but also lots of spaghetti code. The next version is looking a lot better, including this announcement from the lead developer. Templating and styling has to be the most-requested work. I find it a little worrying that OSCommerce is not more openly developed, but it'll be good when the new release ships. Jakob Neilsen has announced the top ten web design mistakes of 2005 and "Legibility Problems" are number one. This isn't a surprise to me. Many websites, including some big names, are totally broken if your browser defaults are light text on a dark background, because that's easier on your eyes. I once spotted the Disability Rights Commission getting this wrong. Even planet.debian.org is missing a:link color: ... . The second top mistake is bad linking, including:

"In particular, don't open pages in new windows"

.which is another thing which I find irritating on many sites. If I want a new window, I'll pick the link for a "new window" from the context menu, or by shift-clicking. Does Mozilla or Firefox or something have an "ignore _blank link targets" option yet? It's only a matter of time. My own company's web site has been updated and I've tried to take these on board. We don't do any of the worst things, but there are always things we can do better. Our site isn't that high a priority - there's so much else to do. The W3C's internationalisation working group has issued a note on working with time zones. I get a lot of unusual time zone requests while programming, but I'll remember these explanations and I think I usually follow the recommendations in s1.5 anyway. Also from W3C is a Working Draft of "Mobile Web Best Practices 1.0" which they'd like feedback on, if you use or develop for mobile web devices. At first glance, it seems that many of the items are stronger versions of the Web Content Accessibility Guidelines. PlayStation chipping is legal in Australia but not in the UK, where it was ruled illegal last year. Chipping is the practice of adding a part to the games console so that it can play imported titles. If the chipping and the risk of breaking it costs less than the difference between imported and domestic releases, some people will want to do it. It's competition between markets. I remember similar things for the old cartridge-based machines of my youth. UK law-makers seem to be trying to kill off that trade in favour of foreign companies that want to tightly control the consoles long after they've been sold. The ruling from Australia might bring the start of a backlash against the increasingly restrictive UK laws, but it's more likely that the EU, US and others will press Australia to fall into line. Copyright seems to be one of the few areas where free trade is being reduced, rather than increased. And finally, I remember the feeling of getting sparc32 Linux working.

Here at Canonical Towers we have several staff who worship at the altar of Extreme Programming, and as such many of the methodologies and rituals prescribed by that religion find their way into our day-to-day working practices. A few of these came together in an interesting way a few weeks ago, and it was suggested by a cow-orker that I blog about it so he could give the URL to people. The first ritual is that of the sprint, I don’t think this is orthodox XP but rather something inspired from it that we picked up from the Python community. With all of the Canonical developers scattered across the globe mostly working from their own homes, it’s become a useful tool; particularly for the Launchpad team. The basic idea for those that haven’t heard of it is simple, and perhaps obvious; you get a selection of the team together in one place, sit them around the same table with particular goals to complete. In effect it’s highly compressed facetime and high bandwidth interaction to nail those tasks that need it, before you head off again and work at a more sedate pace. The second is directly from XP doctrine and is that peculiar observance known as pair programming, something that is often coupled with sprints. For anybody who hasn’t encountered this before, it’s something I’ve always found rather odd. You get two programmers together, both itching to code, and you take one of them’s laptop away; and you don’t just force them to fight over the keyboard either, the laptop-less soul isn’t allowed to touch it. The theory here is that it frees the deprived individual of the hassle of coding and allows them to direct the programmer in ways that may not be immediately obbious, or alternately think about the next bit of work that needs doing. Another interesting side-effect is it can be an interesting way to learn code you’ve not worked with before, if you’re the one doing the coding and you’re being guided what to do by a sage who already knows it. I have a funny story here, so I’m going to digress from the main stream for a moment to tell it. A few months ago I was working in the London office, Mark had been up all night coding and had then given me responsibility to get his changes landed onto the Launchpad mainline. I’m not that hot on quite a bit of Launchpad, and fade to utterly clueless the nearer the code gets to the web application itself; and when trying to merge the two there were conflicts which I needed Mark’s help to resolve. Now as anybody who’s met Mark knows, he’s a pretty good example of a Type-A personality, yet he suggested that we do a spot of pair programming to get the code in and I’d be the one with the laptop as it’d help me get to grips with the affected parts. This hilighted something I’ve always seen as a problem with pair programming, dealing with it when the a person with the keyboard has a totally different way of working to you. In particular, I’m an emacs user, whereas Mark is a die-hard vim user; but also right down to the working directory I would work from, how I test results, etc. When you’re the one without the laptop, this can be quite infuriating, as you know exactly how to solve a problem and the idiot with the keyboard is dithering about doing things you don’t understand just to get there. If you’re a Type-A personality, you generally snatch the laptop away at this point and do it yourself; or at least you would, if you could drive the strange editor the other person uses. I swear Mark was sulking as he gave the laptop back and let me do it. Anyway, there is some relevance to that and we’ll come to it in a moment. The third and final methodology is the concept of unit tests and more specifically test driven development. For anyone who hasn’t come across this before, I highly recommend it; I was suspicious too when Robert Collins took it upon himself to teach me the true way, but now I’m sold. Simply the idea is that if you have any code that doesn’t have another piece of code in a test suite that checks that it’s working correctly, that code is broken. More particularly unit testing involves checking just one feature or requirement at a time, and stacking them together to test all of the code paths. I’ve actually found that this improves the APIs I design, as I write the code in small blocks and functions to make them easier to test. Test driven development takes it even further, you write the unit tests first, before you write the code they’re supposed to test; usually one or two at a time. Obviously these tests will fail at first, it’s then your job to write as little code as possible to make them pass. If your code isn’t right, you add a unit test that will fail, and modify the code to make it pass. This really comes into its own when you’re fixing bugs later, once you’ve identified the bug you write a test case or two that cause the problem; these will of course fail. You can then modify the code to make them pass, and at the same time be sure you’ve not broken other functionality because of the existing test suite. I’ve also found it really useful for particularly complicated or tricky pieces of code, especially those intricate algorithms that do particularly heavy lifting. So onto the event itself, this was a sprint in our London office to indoctrinate Gustavo Niemeyer with the various projects he’d be working on. The goal for this sprint was decided to start the conversion of HCT to Bazaar-NG, and to do this Gustavo and I would pair program. Now my last experience of pair programming had been that story with Mark (see, it had some relevance) and I knew I’d be just as bad if I wasn’t allowed to have the keyboard. I was also acutely aware that if Gustavo was just sitting by and watching, he wouldn’t get much benefit from it either, so he needed to be actively involved in the coding so he could learn the things he’d be working on. I came to what I thought was a pretty neat, and obvious, solution to these problems. We set up my laptop with the code we’d be working on, and on my display were two side-by-side terminals both running screen sessions. Gustavo then set up two same-sized terminals on his, ssh’d into my laptop from both of them and joined the screen sessions. In the left-hand one he ran vi, and in the right-hand one I ran emacs. Thus we both had keyboards, and both had editors, yet could see each other working and even steal the keyboard without danger of violence. We didn’t just sit side-by-side and code on different things though, that’s not pair programming and is just ordinary programming with a bit of a voyeuristic twist. What we did was: in my terminal I started writing the test cases for the code we needed, it was Gustavo’s job to write the code that would make them pass. We actually added a third terminal in which we could run the test cases themselves; so I could run them when I’d added something that would fail, and Gustavo could run them when he thought he’d made them pass again. This turned out to be a rather fun way to work, and at one point I was almost able to try and convince myself that the code was writing itself to pass the test cases I was writing. It also got me thinking that it’d be really neat to use genetic algorithms to breed code to pass test cases.

Robert: A quick Google search on Firefox emacs key bindings gives you what you want. (Bonus points to Google for finding a page that mentions keybindings when I asked it for key bindings .)

My apologies if I haven’t responded to emails within the past few days, I’ve been busy puking.

This time of year it's great to curl up in the evening with a feather comforter and a good text file. I recently read all of Andy Hertzfeld's stories about the origin of the mac on folklore.org, pretty much straight through in chronological order during one long night. Only at the last story did I find out that he'd turned the website into a book. Reading a whole book in one sitting online is not a novel experience for me, though it seems to be for many, but doing it by accident is. My enjoyment of quantities of text online does sometimes come out in my own weblog postings, which are probably long enough, if not good enough, to be their own book. This weblog at least occasionally violates 8 of Nielsen's 10 weblog usability guidelines. The only one I think I should fix is point 5. Another book I read online recently is Karl Fogel's Producing Open Source Software. The contrasts between how Karl suggests doing some things and how projects I'm involved in work are sometimes large (he suggests voting on technical issues for example), sometimes due to differences in technology (the debbugs bug tracker makes conversations and other email-based use of a bug tracking system work much differently than the BTSes he describes using), and sometimes pointed to things that could be improved. More often though, he seemed spot on in extrcting and highlighting best practices. For example, he does a great job in pointing out that simple, consistent naming conventions, like #404093 for a bug report and r1021 for a repository revision, are more important than they appear. I also enjoyed reading some reviews of Katamari Damacy, which sounds like a truely unique and fun game. I'm looking forward to playing it (probably under emulation) one of these years.

My @berkeley.edu email is no more; my @sims.berkeley.edu will probably run out in spring - I'll continue to be reacheable using my regular email address as well as my debian.org email.

Daniel Burrows mentions how he hasn't gotten any reply from potential employers where he sent cover letters that are written like the Rules require. Reading that reminds me how I never ever got hired after writing such a letter myself, either.

• My first job after graduating was at DHL. I got there because I had listed myself on stepstone, a Belgian career site that (at the time, dunno about now) featured a very detailed list of abilities you could claim your knowledge of. Someone at an interim office needed someone for DHL who could work with UNIX and Oracle (both of which I claimed knowledge on that site), so she contacted me; a few days later, I was working at DHL's global headquarters.
• My next job was at a small company in Leuven. I was, in fact, their first employee. I got there after reacting to one of the employers' statements in their .sig on usenet that they were looking for a new employee. A few days later, we met in a bar somewhere in Leuven for a drink. We've had a few more of such meetings, until I was hired.
• Next, I worked at Template. This one was very nice—one of the people who work there, who would eventually become my boss, sent me a private email asking whether I knew someone who could set up an email server and a firewall under Linux. Uh, me?! Turns out he'd been googling a bit, found quite a few postings from me on be.comp.os.linux, and was rather impressed by my knowledge. I didn't have to convince him that it was a good idea to hire me.
• Next I co-founded NixSys. Which obviously doesn't involve job applications, though it is otherwise quite stressful.
• My most recent job (even if only a part-time one) did involve something close to one of those formal letters (not an actual one; but still the first one I ever wrote, actually), though only indirectly; I applied for a job at the department where I graduated first, but didn't get hired there; however, a few weeks later I received an email from someone at a different department (which, obviously, also means a different job). That's about two weeks ago now, and she didn't need any explanation either...
All things considered, I do think the value of such cover letters is highly overrated. Not only do most employers not really care about them; one could also wonder whether you would want to work at a place where paperwork is so important that you couldn't get hired if you're the best guy for the job, but you made an error in the paperwork...