defunct

Important upcoming change: starting Gecko 12, pre-Windows 7 SDKs will no longer be supported

2012-01-26T23:27:00.002+05:30

tl;dr: if you're on an outdated Windows build configuration, upgrade.

I just checked in a patch to mozilla-inbound to drop support for SDKs prior to the Windows 7 SDK. Depending on when you last updated your build configuration, your Mozilla build might break.

Everything's documented on the Windows SDK versions page on MDN; here's a quick summary of what you need to do:

If you're on Windows 2000: Upgrade to Windows XP, Vista or 7.
If you're on Windows XP SP1 or below: Update to the newest service pack.
If you have an older SDK (Vista or 2003): Install the Windows 7 SDK instead. You can either download it separately or use Visual C++ 10 Pro, which comes with it.
If you use Visual C++ 8 (2005) Express or Visual C++ 7.1 (VS2003): Upgrade to Visual C++ 10 (2010; recommended; pro or express) or Visual C++ 9 with Service Pack 1 (2008; pro or express).

MSVC9+ opt builds currently broken due to a compiler bug

2012-01-25T17:06:00.004+05:30

Optimized builds with Microsoft Visual Studio 2008 (VC9) and above are currently broken because of what we believe is a compiler bug. More information and workaround in bug 718541.

C# 5.0 to have fresh bindings per iteration

2012-01-18T15:38:00.001+05:30

Straight from Eric Lippert. Great news. Now if only ECMAScript Harmony included a fix for this bug...

More experiences with an Apple notebook

2012-01-14T18:25:00.000+05:30

It's now been eight months since I got my first Apple notebook. A few months ago I wrote about my initial opinion, where I was pretty sure it would be my last Apple notebook too.

Since then I've had the chance to use it in a variety of situations. Spoiler: none of what I've seen has improved my opinion of it one bit.

The decision to make the outer body out of aluminium is literally shocking. If the notebook isn't plugged in to a grounded socket (for instance, if I'm using the plug that comes with the power brick BY DEFAULT), I'm liable to get electric shocks if I touch the casing. I received a couple of shocks, a mild one and a jolting one, before I realized what was happening. Electrical common sense is that if the outer surface is electrically conducting, it MUST be grounded properly. Having an ungrounded plug by default, or even having one in the first place, is inexcusable. (Update: I've had several people complain to me about this, and one person also complain about his plastic macbook's screws shocking him several times. I'm clearly not the only one with this issue.)
The Wi-Fi reception is the worst I've ever seen in a laptop, and only slightly better than the reception my Nexus S with its puny little antenna gets. Friends tell me it's because the aluminium casing acts as a Faraday cage and attenuates the signal. The "unibody" marketing's clearly far more important to Apple than shipping a working product. (Update: guess who says metal has a "very high" potential to interfere with wireless connections?)
The original power adapters were T-shaped. However, presumably because Apple didn't like the look of and subsequently didn't include the strain-relieving flexes found on all other cables, they were easily frayed. To "fix" this, they started using L-shaped adapters. Of course, what it now means is that depending on the way I insert it, either the power cord blocks the Ethernet port or it gets subjected to strain if I tilt the notebook back.
There's no VGA, DVI or HDMI port, so I need to carry around a set of three dongles everywhere I go. There's plenty of space on the left side, too, so that's not an excuse.
The lack of working sleep is more annoying than I thought it would be. Amazingly, the EFI equivalent to the POST takes almost as long as Windows resuming from hibernation. A few people seem to be working on getting Windows to boot via EFI, and my hopes are mostly pinned on that.

My iPod nano media player, the only other Apple product I own, is actually well-designed (save for the fact that I need to keep the piece of crap called iTunes around on my computer, even though I don't need to use it.) This is not. This stinks of form-over-function failure.

Edit (25/1): Two inline updates.

So, what is recursion?

2011-12-30T01:13:00.000+05:30

Recursion's one of the cornerstones of computer science. The fundamental thesis of computer science says that recursion and iteration (and the untyped λ-calculus) have the same power. People introduced to programming through imperative languages often find the idea of recursion hard, though there are good arguments that that's really a deficiency in our teaching.

So, what exactly is recursion then? And what, for that matter, is iteration?

Wikipedia defines recursion as "a method where the solution to a problem depends on solutions to smaller instances of the same problem". I haven't had major problems with this definition until recently, when I was reading the wonderful Concepts, Techniques and Models of Computer Programming (CTM), which unsurprisingly defines an iterative computation as "a loop whose stack size is bounded by a constant". The examples that it gives are far more surprising, though. Here's an iterative computation to find the length of a list in Oz, the language CTM uses:

fun {IterLength I Ys}
  case Ys
    of nil then I
    [] _|Yr then {IterLength I+1 Yr}
  end
end

Programs like this wouldn't be called iterative in a language like C at all! They'd instead all be called tail recursive. Oz optimizes tail calls so that they don't cause the stack to blow up.¹

Even more surprisingly, and perhaps a bit confusingly, it then goes ahead and calls iterative computations a special case of recursive computations, rather than something distinct. It then talks about converting recursive computations to iterative ones (using accumulators and the like), which I take to mean converting non-iterative computations to iterative ones.

Granted that these definitions are from a declarative point of view, where all state is immutable and thus for or while loops don't make sense, but does that then mean that recursion and iteration can only be defined with respect to the language you're writing in? I've never been fully convinced by Guido van Rossum's arguments against tall call optimization in Python, but considering that the feature can determine whether a given program is iterative or not, the arguments start making a lot more sense.

And what about tail recursion modulo cons then, as found in languages like Haskell and Oz? Optimizing tail recursion modulo cons allows functions that aren't tail-recursive, but where the only thing left to execute after the call is a data constructor like cons, to avoid blowing up the stack². Consider this definition of the map function:

fun {Map F Xs}
  if Xs==nil then nil
    else {F Xs.1}|{Map F Xs.2}
  end
end

This function is clearly not tail recursive, and if translated directly to a language like Scheme which optimizes tail calls but not tail recursion modulo cons, this function would cause a stack overflow with a large enough list. However, since the only thing left after the recursive call is the cons operation (denoted by |), in Oz this function is iterative by the CTM definition³.

So, then, does it make sense to define iteration as any computation in a given language which only takes O(1) implicit (stack) space when executed, and recursion as any computation in a given language which references itself? This would mean that the two aren't quite the opposites they're often portrayed to be, and that depending on the language, recursion and iteration could either overlap or be distinct.

And does it make sense to make this explicit while teaching kids how to program?

¹ Interestingly, Oz doesn't have a separate optimization for tail calls. That tail calls don't cause the stack to blow up follows naturally from the way Oz executes programs, as became clear to me when I wrote a self-interpreter for Oz for a school assignment.

² Again, neither Haskell or Oz have a separate optimization for this. It's a natural, straightforward result of Haskell's laziness and Oz's data-flow variables (everything's a promise in Oz!).

³ Peter Van Roy, one of the authors of CTM and an Oz developer, explains how this happens in Oz.

Why we shouldn't switch to git, part 2

2011-12-25T21:02:00.002+05:30

If unnecessarily bad performance in the usual configuration for anyone on Windows Vista or above wasn't bad enough, msysgit also automatically sets up terrible defaults, leaving first-time developers' heads scratching.

Mercurial, of course, does the right thing here and leaves files alone.

Practically every editor on Windows -- Visual Studio, emacs, vim, Sublime Text -- supports LF endings just fine. As far as I know, Notepad's the only one that doesn't. If you're optimizing for Notepad over everything else, something's really gone wrong.

Why ad blocking is not a moral dilemma

2011-11-14T11:49:00.001+05:30

(These are my own views.)

A common meme doing the rounds these days is that blocking advertisements on sites that depend on it is immoral. I don't believe so mainly because fundamental issues like user sovereignty and control override anything else, but some take the more practical stance that it hurts site owners. I don't think this view is valid. Here's why.

Web advertising is a relationship among three entities. It's not just the user and the site owner who are part of it, it's the advertiser too.
Using ad blockers means the user's not interested in advertising in the first place. Clearly, if she were interested in viewing and clicking on ads, she wouldn't be using an ad blocker. Saying that she should become interested in advertising is not a morally tenable position.
Loading ads without being interested in them hurts the advertiser. Assuming a cost-per-impression model, what would benefit the advertiser more: a thousand impressions to people, all interested in advertising, or ten thousand impressions to people, only 10% interested in them?
A user not interested in advertising has to "hurt" either of the other two in the relationship. Either the site owner is hurt because the user doesn't load advertisements, or the advertiser is hurt because the user loads advertising that she was never interested in in the first place. Deciding which one is hurt can't be left to either the owner or the advertiser because both have vested interests -- so it has to be done by the user. I don't think there's a way to morally distinguish between the owner and the advertiser.
But what about visual impressions? The argument here is the mere sight of advertising, without a click-through, builds up brand recognition and is therefore of value to the advertiser. However, using this as the basis for some sort of normative argument ("you should subject yourself to advertising so that advertisers can build brand recognition in you!") is basically advocating mind control, hence this isn't morally tenable either.

Update: Speak of the devil. A Blogger message just popped up asking if I'd like to add advertising to my blog.

Why we shouldn't switch to git

2011-10-20T13:32:00.001+05:30

Apparently basic support for Windows is considered Somebody Else's Problem. This is easy to work around by using PortableGit instead, but I wonder how many more such Somebody Else's Problems are lurking in the shadows.

Upcoming changes to mozconfig detection

2011-08-24T13:12:00.000+05:30

I just checked in a patch to build-system which changes our mozconfig detection logic. Specifically:

If you want to specify an explicit mozconfig, the only way to do that now is to set the MOZCONFIG environment variable. We used to support the obscure MOZ_MYCONFIG variable too, but we now error out if it is set. ~~Note that if MOZCONFIG is a relative path, it will be treated as relative to the current directory.~~ (update: apologies, this is still broken).
More significantly, we used to support a number of implicit mozconfig locations other than the usual <srcdir>/.mozconfig, such as $HOME/.mozconfig and a couple of variants. This went against build system's policy to be as explicit as possible, so these locations are no longer supported, and if we used to pick up a mozconfig there we will now error out. The only implicit location still supported is the usual <srcdir>/.mozconfig.

This patch should make it into mozilla-central soon, well in time for Gecko 9. This patch will also affect comm-central in the same way

Taskbar overlay icons on Windows 7

2011-08-16T23:41:00.004+05:30

Windows 7's taskbar supports dynamic overlay icons. They're useful for such things as status icons and new mail notifications. We don't support them in Gecko yet, but I have a work-in-progress patch to add support for them.

Playing along

Grab this try build and add this restartless extension to your profile. To change the icon being displayed, go to the extension's options and enter the URL to a 16x16 static image (ICO, PNG, JPG...). These URLs can be anything Firefox supports, including http, file and Mozilla's own moz-icon. Interesting URLs to try out:

chrome://browser/skin/feeds/feedIcon16.png
moz-icon://file:///C:/Windows/explorer.exe
moz-icon://foo.jpg
moz-icon://stock/uac-shield
https://www.mozilla.com/favicon.ico ("yo dawg" if this were an official Firefox build)

Update (today): forgot to add: the extension's available on GitHub too, so grab the source.

MozMill in Thunderbird: looking back and moving forward

2011-07-30T20:57:00.002+05:30

The Thunderbird team started using MozMill a couple of years ago to test UI interactions. From its humble beginnings with a couple of not-really-tests to over 400 tests covering a variety of UI interactions with tinderbox coverage on all 3 major platforms, the Thunderbird MozMill test suite has matured into an important and fairly reliable indicator of frontend code correctness.

It's not always been like this, though -- the test harness has had several major issues over the time it has existed.

Random test failures. These used to be very common before we made a concerted effort to fix them around the beginning of last year. A lot of them were bugs in the tests themselves, but there were at least a few subtle bugs lurking in the code. Making predicate timeouts count as failures helped a lot in tightening things up. A few random failures still remain but they're infrequent enough that we don't have to make fixing them a top priority.
Linux support. We got MozMill tinderboxes for Windows and Mac up pretty early, but Linux tests were broken for the longest while. The tests ran in a different order, the wrong part of the UI ended up receiving any keystrokes made... it made Linux frontend developers' lives a pain, and it took a rather large patch from the wonderful asuth to finally fix things for good. MozMill tinderboxes for Linux were finally turned on some time early this year.

It's still not as good as it can be, though. Some of the issues that remain are

IMAP, SMTP and NNTP support. We've had fakeservers for all the protocols we support for a while, but because of the way they work they're limited to xpcshell tests for now. Thus one can't write a frontend test that focuses on issues with our UI with IMAP servers (and we have plenty of those). This should be fixed right after jcranmer moves the fakeservers out of the main process, and I look forward to seeing the first IMAP tests soon.
Outdated MozMill versions. The MozMill developers have introduced subtle API changes over time, which means we haven't been able to move to more recent versions as easily as we'd hoped to. (Not blaming them, though, since MozMill was still pretty immature when we decided to start using it.)
External dependencies. Imagine you're a new developer who'd like to get started with your first MozMill test. You discover that you need to install a list of packages through easy_install or similar. You can't just easy_install mozmill, either: since we don't work with the latest version of MozMill, you need to specify the URL to each package you need. If you need a different version of MozMill for something else, you need to learn about and use virtualenv. All this is far more troublesome than it should be.

Well, good news, everyone! We're soon going to move MozMill to within the tree as part of a larger patch to upgrade it to the latest version. (The move was spurred by the fact that we didn't want to check the requisite test fixes into older branches and all our branches were tested by the same builders so had to have the same version of MozMill installed. But let's not focus on that. :) ) Once the patch is in the tree, you'll be able to run MozMill tests without installing anything else.

MozMill's future is bright: more developers will be able to write tests for more of our code faster and better.

Why you should care about: idempotence and nullipotence

2011-07-29T02:06:00.004+05:30

(The information in the post is somewhat basic and will probably be known to a lot of people, but it's meant more to get my own thoughts straight on the matter than anything else.)

In mathematics, an operation is called idempotent if it can be applied over and over without changing the answer. We've all seen such operations: a familiar example is the absolute value function. (Apply it to a number like -5 and you get back 5. Apply it again and you still get back 5, and so on.) An even simpler example is the identity function: applying it twice is the same as applying it once, which interestingly is the same as not applying it at all.

In computer science, the word can either retain this meaning, and then be used to describe functions like Math.abs(), or take on a slightly different meaning: a function call is idempotent if any side effects it has remain the same when the function's called again. So, for example, a database query saying "insert or update row 42 with the given details" is idempotent -- whether it's executed once or a hundred times, the end result is going to be that the table's going to have a row 42 with the given details.

Idempotence is also important when you're dealing with transactions and trying to redo one on failure: if you know a particular operation in a transaction is idempotent, you can redo it without worrying about whether it already happened the first time.

Related is the idea of nullipotence: a function is nullipotent if not calling it at all has the same side effects as calling it once or more. In practice, this simply means that the function doesn't have any side effects at all. A database query saying "get row 42" is a good example. Nullipotence is clearly a stronger condition than idempotence.

So why am I posting this on a Web-centric aggregator like Planet Mozilla? Well, it turns out that the ideas are fundamental to HTTP. Of the four basic HTTP verbs, GET is nullipotent, PUT and DELETE are idempotent but not nullipotent, and POST isn't idempotent. (It's straightforward to see why.) This means that:

GET requests can be cached, since it doesn't matter whether the server sees the request at all.
It's safe for web crawlers to make GET requests.
You get to see an annoying but unavoidable dialog box if you refresh a POST request, such as this:

Of course, none of these requirements are actually enforced by anyone -- it's really easy to write a server-side script that modifies database rows on a GET request, for instance. They're definitely assumed by others that interact with your service, though, which means you really should adhere to them. On the flip side, you shouldn't use POST for an operation that would work with GET, since that'd lead to your users having an unnecessarily bad UX.

My experiences with an Apple notebook

2011-07-03T17:46:00.001+05:30

A couple of months ago, I got a new Apple 15" notebook (Macbook Pro). The trackpad's size is nice and the screen looks good, but everything else has been quite horrific.

Double-click to drag doesn't work properly.
I get significantly less battery life in Windows than in OS X because Apple doesn't bother exposing the Intel graphics to non-OS X installs, just the AMD ones.

These weren't big concerns to me, though. Where things seriously took a turn for the worse is when I decided to get a solid-state drive for the notebook to make Mozilla builds (and everything else) faster.

The screws to open up the notebook were so tight that I stripped them in the process of opening them. I had to go to the nearest Apple store to get them opened up. Turns out they use some sort of blue-coloured adhesive to hold the screws in place. (WTF?)
According to the support rep who helped me out (no, I'm not going to call him a "genius"), installing the SSD technically voids the warranty. It's not a big deal because easy to put the original hard drive back in, but it's just wrong to void the warranty for that.
Once I installed Windows onto the SSD, I benchmarked it. To my surprise, reads were only 180 MB/s or so and 4K random reads and writes were only happening at roughly 4000/second, several times less than they should be. Turns out non-OS X installs don't get AHCI (WTF?!?!?!), which means they don't get native command queueing, which is rather essential for a high random IOPS rate.
Now there is an MBR hack available to turn AHCI on, but the hack breaks sleep. So now I'm faced with the absolutely ridiculous choice between working sleep and getting the full value out of my SSD. (I'll probably turn AHCI on, simply because I don't put my notebook to sleep *that* often and can wait the 30 or so seconds it would take to come out of hibernate.)

This is the first time I've had an Apple notebook, and I'm pretty sure it's going to be the last.

Tip: if you’re trying to use a XUL for anything more than a trivial, static dialog…

2011-06-26T13:41:00.001+05:30

… don’t. Use a XUL window instead, and reorder the buttons to match platform standards yourself (perhaps using CSS ordinal groups). You’re going to save a lot of hair from being torn out that way.

Update 27/6: Enn pointed out that I should file bugs for my issues. He’s right, so here are the bugs I’ve filed so far.

Refreshing the icon cache on Windows

2011-06-01T03:40:00.001+05:30

I was writing some code that dealt with icons in the Windows UI and wasn't able to get it to work. Turns out the Windows icon cache was getting in the way. If you're having the same problem, here's a small Python script that'll clear out the icon cache for you.

Openness and reputation

2011-04-04T22:56:00.001+05:30

So it’s old news now, but Google has decided to withhold Android 3.0’s source code for the next few months. Why? Because according to Andy Rubin, head of the Android group, the software isn’t ready for phones yet, and Google couldn't prevent developers from putting the software on them “and creating a really bad user experience.” Google’s solution is to shut off public access to the source code entirely. As expected, the company has been roundly criticized for this decision.

It is worth recognizing that the problem does exist: I personally know people who bought cheap Android phones with terrible UX, and have now sworn off Android for the rest of their lives. The first Android tablets tried to shoehorn the phone UI into the tablet form factor, and were worse off for it. Android’s brand value has clearly been diluted by such devices, and Rubin is now in damage control mode.

However, he’s going entirely the wrong way about it. The root of the problem is not how open the source code is – it’s to do with how liberally the Android trademark is licensed.

In a recent post, Gerv mentioned some of the issues with community-equal trademarks. It turns out that the problem is more general: it happens even if trademarks aren’t community-equal but also aren’t sufficiently protected. Even though Android has a compatibility program in place, if one goes by Rubin’s words it apparently isn’t powerful enough to prevent companies from releasing devices with bad UX and calling them Android devices. (Either that or Android’s openness really is a “marketing gimmick”, as the Ars Technica article says.) If Google had sufficient control over its trademark, it could have released the source to Android 3.0, and then put its foot down and said “no Android 3.0 phones, full stop”.

On the other hand, Mozilla, as a truly open organization, recognized this problem long ago and restricted its trademarks from the beginning. Despite blowback from Linux vendors, Mozilla hasn’t relented much. The philosophy is simple: you have a right to our code, but you don’t have a right to our reputation, and in a capitalist world, your trademarks are your reputation. And the philosophy has worked.

I think there’s a lesson here for open source projects: Your trademarks define you in the marketplace, and are your own responsibility. Protecting your trademarks is the right thing to do. For consumer-facing software, it is the moral thing to do. Android didn’t, and now has to compromise on its openness to fix its problems.

(Obligatory disclaimer: these views are my own.)

Hard-linked chrome now supported on Windows

2011-03-02T18:03:00.001+05:30

If you pass --enable-chrome-format=symlink in as an option to configure, any chrome files that don’t need to be preprocessed are symlinked instead¹. This is really useful because it allows for a much quicker edit-test cycle – you don’t need to run make every time you edit a file. However, the option only works on platforms that have historically supported symlinks, i.e. Mac and Linux.

… until now. I checked in a patch to the build-system repository yesterday adding support for the option on Windows. Instead of symlinks, though, the option creates hard links². This isn’t a big deal: the edit-test cycle is as quick as it would be with symlinks.

mozilla-central is in lockdown mode right now, so the patch will only be merged into it after it branches for Firefox 4. You don’t need to wait, though – grab the patch from bug 634596 and apply it to your tree.

Note that

Your source and object directories need to be on the same NTFS partition.
If you use an editor that breaks hard links by default, you will need to configure it to not do so. For Emacs, add the line (setq backup-by-copying-when-linked t) to your .emacs.

¹Yet another reason preprocessed chrome files suck.
²Why? Firstly, symlinks aren’t supported on Windows XP or 2003. Secondly, even though they are supported on Windows Vista and 7, creating them requires you to be an elevated administrator. Even if you grant yourself the required SeCreateSymbolicLinkPrivilege, if you’re an administrator UAC takes it away.

A note about Services and MailServices

2011-02-13T20:43:00.001+05:30

Turns out you shouldn’t blindly replace code using Components.classes with its Services or MailServices equivalent. Anything you get from them won’t be strictly equal to anything you get via Components.classes. For instance,

var ct1 = Services.tm.currentThread;
var ct2 = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager).currentThread;
ct1 === ct2

will be false. Even if you don’t use === explicitly in your code, you might implicitly use it, with e.g. indexOf.

See bug 632422 for the gory details.

MailServices

2011-02-05T23:29:00.001+05:30

Gecko 2 has the very cool Services module, which gives JavaScript code quick access to a list of commonly-used XPCOM services. No more remembering an arcane contract ID every time you need to access, say, the preferences service – all you need to do is type in Services.prefs.

A few days ago, I proposed adding a similar module called MailServices for access to mail/news services. The module is now available for Thunderbird and SeaMonkey’s core and extension developers to use – if you’re in a Thunderbird mail window’s scope, it’s already available to you; otherwise, all you need to do is

Components.utils.import("resource:///modules/mailServices.js");

The module is available in nightlies and will be part of Thunderbird 3.3 alpha 3 and later.

Thunderbird about:support landed

2011-01-15T01:03:00.001+05:30

I just pushed a patch to comm-central landing about:support in the tree. If all goes well, it’ll be part of Thunderbird 3.3 alpha 2. The extension will remain available to Thunderbird 3.1 users, and I’ll shortly release an update hard-disabling it on Thunderbird 3.3 alpha 2 and above.

It’s been a great experience driving the project through to graduation. Using the Firefox version of about:support as a base, we looked at what other data’s needed for effective Thunderbird support, and how best to present it to the user while keeping privacy in mind. The model of rapidly iterating on new features by developing them as extensions is a great one.

Thanks to Roland, Bryan, Eric Moore, and everyone else who contributed with bug reports, appreciation, criticism, or in any other way.

Lightweight JavaScript dictionaries with arbitrary keys

2010-12-23T00:28:00.001+05:30

A well-known fact is that you can use any¹ JavaScript object as a dictionary (map) from strings to objects.

> var dict = {};
> dict.key1 = "foo";
> dict["key2"] = "bar";

This works well as long as the keys are constants, or in general under your control. However, things don’t work as well when you start allowing arbitrary, user-controlled keys. Say you use the tags defined in Thunderbird as keys. What happens if a user defines a tag named “watch”?

> var dict = {};
> ("watch" in dict)
true

Uh oh.

You might suspect that hasOwnProperty fixes this, and it does, but

it’s clunky
it doesn’t fix other magical keywords like __proto__ (though I’d like to know what sort of user has a tag named __proto__ :) )

Even worse, since __proto__ is both non-enumerable and non-configurable, it’ll be lost in a for..in loop.

There are other issues too: subtle changes in semantics because of a key named toString, for instance. What if a programmer has a debug statement printing out a dictionary somewhere (not that it’s generally too useful)?

Clearly, plain objects don’t cut it for arbitrary keys, so we in Thunderbird needed something a little more sophisticated. We still wanted to retain most of the speed of direct property access, though. I spent a weekend investigating what we could do, and what was finally agreed upon was a lightweight wrapper around objects.

The API (get/set/has/del) is inspired by, but somewhat different from, Python’s dict API. Of course, now that we’re using a wrapper anyway, we can add convenience stuff to make using it more enticing:

separate iterators over keys, values and key-value pairs
a working toString function!
a count property

We’ve landed this in comm-central and it’s available to any Thunderbird, SeaMonkey or extension developers who want to use it – ~~simply use Components.utils.import("resource:///modules/dictUtils.js"); to import it into your scope.~~ For examples, see the tests.

Here’s the GitHub repository where I experimented, including an aborted attempt to use ECMAScript 5 proxies.

Update (23/3/11): The module’s in mozilla-central now! To use it, add the line

Components.utils.import("resource://gre/modules/Dict.jsm");

to your scope.

¹ You should only be using plain objects as dictionaries, though. In particular, you shouldn’t be using JavaScript’s Array objects as dictionaries.

js-ctypes

2010-07-26T14:55:00.001+05:30

Over the weekend, I decided to learn js-ctypes. The best way to learn an API is by using it for something non-trivial, so I wrote a patch to move a bit of code calling Win32 functions I had written a few months ago from C to JavaScript. Overall, I was pleasantly surprised at how simple it is to use.

The documentation sucks a bit at the moment – I found that the best way to experiment was to use the xpcshell REPL. I’m sure this will be fixed in time for Firefox 4.0.
The js-ctypes type hierarchy makes complete sense. I haven’t used any other equivalents (python ctypes, .NET P/Invoke), but I hope they’re similar.
There is a good deal of type checking built into the API – more than I’m used to from a dynamic language, at any rate. If only JavaScript were statically typed…
Declaring Win32 types and functions is simple enough – just look them up on MSDN. Declaring constants can be harder, since not all constant values are provided on MSDN. To get some of them, I had to resort to grepping the Microsoft SDK include directory, and in a couple of cases writing and compiling small C programs to print the value.
Comparing pointers is annoying. That was probably what I spent the most time figuring out. I ultimately cast my voidptr_t into an intptr_t and worked with its value, which is a ctypes.Int64.
I hit one major gotcha – in JavaScript, the operands of bitwise operators are signed 32-bit integers. In particular, 0x80000000 | 0x40000000 = –0x40000000 and not 0xC0000000. This impacts how bit flags work. Ways to avoid this include adding up the flags instead (as long as you know all the flags you’re adding are mutually exclusive) or simply using the composite flag.

Other than these two things, if you already have the C code in front of you, translating it to JavaScript line by line is quite straightforward. I didn’t deal with callbacks, so I’m sure there will be some added complexity there.

Modern times

2010-04-08T00:23:00.001+05:30

Typography on computers has improved tremendously in the last ten years. Microsoft came out with ClearType with Windows XP (spurring endless debates about whether Apple’s or Microsoft’s sub-pixel rendering technology is better), and then with an amazing set of typefaces with Windows Vista. Meanwhile, Apple’s done its own share of shipping new typefaces in OS releases. And most Linux distributions now ship the excellent DejaVu typefaces.

Thunderbird, however, hasn’t kept up at all, despite the fact that its primary job is to display text to you. On Windows, it still uses the ancient Times New Roman and Courier New fonts, even though Microsoft itself has moved on.

Thunderbird 3 on Windows 7 next to Mozilla Suite 1.0 on Windows 98: spot the difference

This is all about to change. Starting Thunderbird 3.1 beta 2, the default typefaces for emails in Unicode and Western encodings have changed from:

Windows Vista and 7

Proportional: Times New Roman to Calibri
Monospace: Courier New to Consolas

Mac OS X

Proportional: Times to Lucida Grande
Monospace: Courier to Menlo on Snow Leopard and later, Monaco otherwise

Linux

Proportional: System default serif typeface to ~~DejaVu Sans~~ system default sans-serif typeface
Monospace: System default monospace typeface ~~to DejaVu Sans Mono~~ hasn’t been changed

These typefaces provide a fresh, modern look to Thunderbird, and make the experience of reading email that much better.

A comparison of the old and new defaults on Windows and Mac

Unfortunately, we don’t have a solution for Windows XP yet, mainly because ClearType isn’t enabled by default and neither are ClearType typefaces always available. There’s a bug on file to upgrade Windows XP users to something better than the current defaults.

Thanks to Alex Faaborg for first suggesting the idea of changing the default fonts, dmose for driving it over the line, Mossop for suggesting the defaults on Mac, and Blake and Bryan for reviewing it in time ;)

I’d also like to thank Gurpartap for allowing me access to his Mac server over VNC to take screenshots. (No thanks to Apple for making connecting to Snow Leopard Server from a non-Apple computer a PITA, though.)

Update: The Linux defaults have been reverted to whatever the system specifies.

Update 2: Patricia Clausnitzer from PC has kindly provided a Belorussian translation of this post.

Today I learned…

2010-03-05T02:11:00.001+05:30

…that Mozilla trunk fastload caches modules, so if you have an opt build and you modify a module you need to nuke *.mfl from the local profile directory.

Sigur Rós

2009-12-07T18:52:00.001+05:30

Their music (Wikipedia) is some of the most emotional I’ve ever heard. Combining elements from ‘70s prog rock and bands like My Bloody Valentine, they manage to produce something completely unlike anything else in this world. Standouts include Starálfur from Ágætis Byrjun, Hoppípolla from Takk…, and Festival from Með Suð Í Eyrum Við Spilum Endalaust. But really, all their stuff is great, and Jonsi’s voice is… unique. Start with Ágætis Byrjun if you want to jump right into the deep end, or with Með Suð Í Eyrum Við Spilum Endalaust, which is their “poppiest” record.

One Very Important Thought

2009-08-31T01:13:00.001+05:30

Now that the show is over and we have jointly exercised our constitutional rights, we would like to leave you with one very important thought, sometime in the future you may have the opportunity to serve as a juror in a censorship case or a so called obscenity case. It would be wise to remember that the same people who would stop you from listening to Boards Of Canada may be back next year to complain about a book or even a tv program. If you could be told what you can see or read then it follows that you could be told what to see or think. Defend your constitutionally protected rights, no one else will do it for you. Thank you.

From the end of Music Has the Right to Children by Boards of Canada.

Apparently this is sampled from the end of an adult film (SFW). “Jointly exercis[ing] our constitutional rights…” I like the euphemism. :)

Using object destructuring to implement named parameters in JavaScript

2009-06-08T19:28:00.004+05:30

One of the neat things about JavaScript 1.7 and up is the support for array destructuring. It allows you to do things like

function foo() { return [5, 10]; }
let [a, b] = foo();

or even

function bar([a, b]) { return a + b; }
bar([5, 10]);

While the first example is obviously useful, the second one is somewhat less so. However, I didn’t know just how useful the general idea behind the second example is until this weekend, when asuth pointed out on IRC something I’d been previously unaware of: JavaScript supports object destructuring too. This means that you can do stuff such as

function baz() { return {a: 5, b: 10}; }
let {a: x, b: y} = baz();

Here, x and y will be 5 and 10 respectively at the end.

And yes, you can even write

function quux({a: x, b: y}) { return x + y; }
quux({a: 5, b: 10});

This looks like a great way to implement named parameters for your functions whenever you need them.

But wait – there’s more! There’s even a shorthand for when the property name is the same as the name of the variable you want to assign to. The last example could be rewritten as

function quux({a, b}) { return a + b; }
quux({a: 5, b: 10});

Depending on your use case, this might be an even better way to implement named parameters!

Note that the shorthand only works for destructuring assignments – you can’t use it to create (or “structure”) objects.

Long-lived JS objects without references considered harmful

2009-05-16T20:10:00.006+05:30

I was having trouble getting the unit test for bug 466227 (make gloda index the headers of IMAP messages that aren’t offline) to work. The test involved the IMAP fake server which we have in the tree, and was failing consistently after fetching the headers of exactly six messages.

IMAP logging revealed that the connection was getting dropped right after the sixth message was completed, and that we were trying to reconnect to the fake server to execute the next command. Now, the fake server currently supports only one connection in its lifetime, so after getting the second connection attempt, it responded with an error message.

Clearly there was something unexpected that was causing the connection to drop, but we had no clue why. After a few false starts, I finally enabled logging on the socket transport service, and that revealed that nsSocketTransport::OnMsgInputClosed was getting called.

Setting a breakpoint there revealed nothing particularly significant (other than that an nsPipeInputStream was getting destructed) in the socket thread’s call stack, but something very interesting in the main thread’s stack:

We were in the middle of a JS garbage collection run – a forced one, no less. A DumpJSStack() on the main thread showed that this line in the gloda indexer was responsible. Sure enough, commenting out that line was enough to make the test pass.

bienvenu had the idea that one of the fake server’s internal objects was the one getting GCed, as we hold strong refs to any input or output streams that are given to the IMAP code.

After that, since I didn’t know of a way to uniquely identify the object getting GCed, it was a matter of brute force. Inside an nsPipe, the mStatus determines the status of a connection. So I set a breakpoint at nsPipe’s constructor, and then every time we hit the breakpoint, I ran a DumpJSStack(), noted down the JS caller along with the memory address on a sheet of paper, and set a data breakpoint for that pipe’s mStatus.* The third pipe was the one giving trouble, and that corresponded to this innocuous-looking line.

The fix was inordinately simple – just push the input stream into a long-lived array, thus making sure that we always hold a ref to it.

Huge thanks to bienvenu and asuth for all the help.

* Surely there’s a better way to do this (maybe using gdb instead)? i.e. run DumpJSStack() automatically, set a data breakpoint at mStatus, and log the DumpJSStack() output and the memory address somewhere?

(minor edit for clarity)

Support for Windows SDK versioning in mozilla-central

2009-04-22T20:25:00.002+05:30

Mozilla uses the Windows SDK for official builds on Windows. Newer versions of the Windows SDK usually add support for features found in newer versions of Windows – for example, the Windows Vista SDK added support for parental controls, stock icons, and the new Vista method of file association registrations.

Unfortunately, we can’t expect everyone to upgrade to the Vista SDK, because you can’t install it on Windows 2000. Some people also build with GCC, which doesn’t support any of the Vista stuff either. Since Vista SDK headers can’t be included in the tree as-is, the solution for that was to add a new flag.

The Windows 7 SDK adds a few more features that we’d probably like to support, and it was clear adding SDK specific flags willy-nilly to configure.in is not a good solution in the long run. Patches to add a generic way to detect and enable SDK versions have finally landed on trunk.

What’s changed?

The option --with-windows-version has been changed to mean the Windows version to target using this SDK (the default is 600, which is Windows Vista).
configure.in will detect which SDK you’re building with, and will exit with an error if it’s too old.
--disable-vista-sdk-requirements is now deprecated – you should use --with-windows-version=502 instead.
Once the remaining patches on that bug land, you should be able to specify Windows SDK versions by saying #if MOZ_WINSDK_TARGETVER >= MOZ_NTDDI_X, where X specifies the minimum version of the SDK needed. Currently, X can be either LONGHORN, which should be used around code that needs the Vista SDK to build, or WIN7, for the Windows 7 SDK.
Makefiles can’t be used for this any more.

What hasn’t?

_WIN32_WINNT, WINVER and NTDDI_VERSION haven’t changed – you’ll still need to bump them up within a file if you need to.
mozilla-1.9.1.

Seven things

2009-01-15T01:28:00.004+05:30

I can has internet meme too? Thanks, jcranmer.

The rules.

Link back to your original tagger and list the rules in your post.
Share seven facts about yourself.
Tag some (none? :) ) people by leaving names and links to their blogs.
Let them know they’ve been tagged.

The things.

I’m a huge video gaming freak – I think I played my first game of Super Mario Bros. well before I first spoke. For some reason, for a long time I thought that the Koopas were ducks and not turtles.
My first web site had a lot of those “cool” Frontpage “DHTML” effects and animated gifs. My little mind at that time couldn’t even comprehend someone hating such an awesome thing. Oh, those were the days.
I’m not the kind of guy who picks fights, but had this knack to get involved in them. :(
I like to listen to a lot of classic rock, prog rock, blues rock, jazz-pop, and trip-hop, but I haven’t yet found a metal band that I like. (Opeth comes close – maybe I need to give them another proper listen.)
In my opinion, Arrested Development is probably the best TV comedy in existence. It isn’t really meant for TV, though; you need to be able to rewind or go back episodes to catch some of the subtler funnies in it.
I’ve been playing around with various Linux distros for close to eight years now. I remember installing Red Hat 7 for the first time around 2001. (I’m still not sure whether the CD I had was legal or not.) I even switched full time to Ubuntu for a while. All my attempts have ultimately led to frustration with something or the other, though, and I’ve been back on Windows for around a year and a half now.
I’m unable to parse images (like icons) as easily and quickly as text. However good the rest of OS X might or might not be, I don’t think I’ll ever be able to use it, as I have a lot of trouble with the OS X dock.

The taggees (sp?):

Mark Banner
Jeff Beckley (don’t think he has a blog, though)
Josh Geenen, fellow Mozilla GSoC student
Nirbheek Chauhan
Naresh V
Arun Chaganty

End of the Google Summer of Code

2008-08-26T16:38:00.001+05:30

The Google Summer of Code 2008 coding phase ended a week ago, and final evaluations are currently on. My GSoC project was about integrating Thunderbird with Windows Search, so that people can search for emails on Windows as conveniently and quickly as they search for documents and other files.

What's been done?

How much of what I initially set out to do has been completed?

There's a patch up at bug 430614 that adds almost full fledged support for Windows Search integration on Windows Vista to Thunderbird. It seems like it should land for Thunderbird 3 beta 1.
A lot of the backend code that sends notifications of messages or folders being added, copied, moved or deleted, has been fixed. These notifications are essential for the instantaneous indexing I hoped to achieve. Now, with the profile on an NTFS file system, and the Thunderbird and Windows indexes in their steady state, new messages should be indexed within seconds of arrival. Right now, the indexing code is the only core code that uses the notifications, but I understand that gloda will use it too for its incremental indexing. This should also be useful for extension developers looking to keep track of messages and folders. Fixing the notifications and writing tests for them did take a substantial amount of time, though.
Spotlight integration on OS X, which was introduced in Thunderbird 2, has also received several fixes because of a lot of code being shared between the two.
More code that has been rewritten includes GetMsgTextFromStream and the code to open Thunderbird from a search result.

What hasn't been done so far?

A good UI within Thunderbird to manage indexing. The plan right now is to merge this with the default client dialog, presenting a unified "OS Integration" dialog. Let's see how it works out. If you have a suggestion, please let me know!
Windows XP support. Windows Search for Windows XP lacks a "property handler" which can be used to parse MIME messages and present useful data about the headers in a UI, and also allow filtering results based on them. (This is built into Vista, and we make use of it. So, you can type in from:xyz in the search box and get results based on this.) An option is to write our own property handler.
Proper support for indexing newsgroups. Specifically, notifications for deleted and copied messages.
I guess that if support for indexing newsgroups lands, support for turning off search integration for particular accounts should also be present. Right now it's a global setting, but adding per-account support shouldn't be too hard. One thing to figure out is how messages moved between indexed and non-indexed accounts should be handled. Question: should the granularity be per-account or per-folder? Per-folder gives more control but has bigger problems than per-account.
One concern that asuth had is that we currently send "message added" notifications for individual messages, as soon as the message is added to the database. If a new folder with thousands of messages is added, we'll have thousands of notifications, and those many XPConnect boundaries being crossed. One idea is to implement a token bucket system which batches multiple messages in one notification. This, like all asynchronous programming, has its own set of issues, of course: what if a message is added, but moved or deleted before its notification can be sent?
Another aspect that deserves at least a brief look is the possibility of presenting results from Windows Search within the Thunderbird UI.

What have I learnt?

This was my first time participating in a large open source project, and I'm grateful to Google for the incentive to do so. My job definitely isn't over yet, and I'd like to continue to work on this until it gets into a very usable state. (Apologies for any rambling below.)

The final product might be completely different from the initial plan. The plan I'd put forward in my GSoC application just couldn't work.
There are surprises everywhere. Every time you accomplish something and think that it's finally about to be in a usable state, you realize another part needs fixing. First it was the notification code. Right now my concern is with the UI, and clarkbw has some great ideas, one of which (the unified default client/search integration dialog) looks to be the way to go. Right now, though, apart from the UI, there don't seem to be any major, debilitating issues with the integration -- though I've hit upon a few edge cases, which seem to be caused when the account settings are absolutely mauled, where the search result handling breaks, and I'm looking for fixes to them.
The old Windows developers had it easy. A separation of your program into administrative and non-administrative parts forces you to think carefully about what to add to each section, and about how to go about doing this with a minimum of hassle to the user. Right now we require one UAC prompt to enable integration and one to disable it, which looks like it'll be the minimum required.
Wherever it can be used, automated unit testing works. It makes you be a bit more confident about the code than if you had relied on manual testing, and it protects against regressions that others or you yourself introduce. (I still go "doh" at that. :( ) Full credit to Standard8 for driving automated testing for mail/news.
Tougher reviews are generally better. Old code that doesn't seem to follow any particular coding style is just plain harder to fix. Good, readable code is also easy to modify. Of course, there's the issue of patches being held up for too long.
You can't assume any code that interacts with the OS platform, however old and well-tested, will work the same across platforms. Apple should -- no, must -- allow its OS to be virtualized, because debugging over IRC just isn't fun.

Thanks to...

(hopefully I'm not forgetting anyone) Jeff Beckley, my GSoC mentor, for spending a ridiculous amount of time with me (I guess far more than I deserved), with guidance in both overall direction and specific implementation details. David Bienvenu and everyone else at #maildev and #developers, for answering every potentially stupid question I had (though I hope the SNR wasn't too low :) ). Leslie Hawthorn and everybody else in charge of GSoC at Google, and Gervase Markham, the Mozilla GSoC administrator, for making this possible. ... and Arun Raghavan, a GSoC 2007 veteran from my college, for holding a small lecture about GSoC (I think on March 13) that got me interested in it in the first place. What a wonderful experience GSoC was!

The sheer pain of platform-specific code

2008-06-25T19:39:00.008+05:30

So I submitted a patch to bug 436880, with some innocuous-looking tests. There were a couple of fixes needed to make the test work (and in general), but nothing major. All the tests passed on my Windows build like a charm. All was well, until Standard8 tried out the test on his Mac and found that it failed with:

###!!! ASSERTION: You can't dereference a NULL nsCOMPtr with operator->()

Yes, a null pointer. After some initial shots in the dark (Time gaps before the next test? Line endings?), it was time for some debugging. It later turned out that when an instruction was given for multiple messages to be moved or copied, only the first one was actually being copied. As any further messages were not copied at all, we got a null pointer when we tried to retrieve them. It was utterly surprising for me to see

such a problem being platform dependent.
such a basic operation having trouble -- except for the fact that this only happened in tests. (Don't worry Mac Thunderbird users -- your messages are safe ;) )
the problem happening only when multiple messages were moved or copied in one go.

I filed bug 439925 regarding this. One major problem was that I don't have a Mac to test on -- so all I could do was ask Mac users to run different tests with debugging information. (Thank you once again, Jeff and Standard8, for your valuable time.) Finally, this Monday, David Bienvenu had some time to debug this on his Mac. He found that while copying messages from data files into a mail folder, the "folder" of the message object wasn't being set properly on OS X. (It was, on Windows). When multiple copies were done, we were sending the first message's source folder ourselves, but subsequent copies were using the "folder" set in the message object. Now, why exactly wasn't the folder being set properly? David explains it best. Lesson: Bad things can happen with non-normalized paths. (Non-normalized paths are paths that are something like foo/bar/baz/../../quux. Ideally, this path should have simply been foo/quux. Most of the time, both are equivalent. When they are not, as in this case on OS X, bad things happen.) The fix was simple, just one line long. All's (finally) well again with the world. ~~It isn't. Again, this happens on OS X but not on Windows. Bah. Seems like I'll go through this all over again. :(~~

One Windows terminal to rule them all.

2008-06-13T17:14:00.005+05:30

Console2

So I'm 19 years old now.

2008-06-05T03:11:00.004+05:30

What's changed in the past year?

I finally got out of school and into IIT. What a refreshing change from the monotony of school. (It quickly wore out though.) It's a relief to go from 7 hours a day (which got extended to 10 by class 12), 6 days a week to 4-5 hours a day, 5 days a week. However, the coursework is stepped up a level, which sort of cancels this out. It's also my first time living in a hostel. I was overprepared for the change, so I didn't notice it too much :) It's a lot of fun, though you learn to respect home-cooked food.
I've got a new laptop, a Dell Inspiron 1520. My last computer is now seven years old, and the change was desperately needed. Compiling was slow as molasses on the desktop, and the only games that worked were emulated ones (SNES hooray). Dad's using my old computer now; he has few needs apart from email and word processing.
(Apologies for the Wikipedia link spam below) I've developed a taste in what I think is good music, mostly thanks to a great friend of mine. It started off with less listened to (but still great) stuff like video game music, Simon and Garfunkel, and Sufjan Stevens. Dad's been asking me to listen to the Beatles for several years now, but I've never, ever listened to him in my life. I did heed my friend's advice, though, when he asked me to listen to them, and I instantly fell in love with them. Today, I think that the Beatles are the best band ever. From there I started listening to Jethro Tull, Brian Eno, Jeff Buckley and after that The Who (Quadrophenia is brilliant). More recently, I've been listening to Porcupine Tree (a lot), The Answer and Joe Bonamassa, all recommended by friends. I think my current taste in music is quite accurately reflected in my last.fm profile. And no, I don't like Led Zeppelin (apart from maybe Stairway to Heaven).
I'm finally experiencing just a bit of large scale open source software development, thanks to the Google Summer of Code. All the stuff I've done so far is really basic, and I've still had problems. There's tons more I need to learn.

I guess I'm just forgetting a lot more that should be here.

Update, patches accepted

2008-05-31T03:04:00.004+05:30

With two more patches -- one to enable support for my .wdseml file extension, the other to remove an old array API from a part of the code base -- finally accepted, it's time to focus on IMAP. The main problem is that itemDeleted notifications aren't firing at all for messages. They have to fire at two places at least:

When an item, that was previously there, has mysteriously disappeared.
When an item is moved from one folder to another -- this is because the destination folder, when opened, fires an itemAdded notification. itemMoveCopyCompleted can't really work, as you really can't stop the dest folder from doing an itemAdded. (Hmm, it's possible, though: callers can simply ignore the itemAdded? No, that'll only complicate matters further. Let's see)

Most of the patch is ready, and I think I'll put it up over the weekend. This is fun!

Working code... (sorta)

2008-05-18T16:32:00.006+05:30

With bug 433740 checked in, the patch to bug 433697 hopefully getting r/sr+, and some registry entries that (right now) have to be manually added, the code has started "working". The results for local folders are correctly written out, appear as part of the index search results under "E-mail", and open correctly when selected.

There's still a lot to do, though.

IMAP notifications are still a bit broken, moves and deletes mainly.

Support reply/forward straight from the search results, like this:

Mails with no subject have their "ugly" filenames show up when searched from the Start menu.

What about junk mails?

... and probably a lot more.

My first patch

2008-05-13T13:20:00.003+05:30

I submitted my first patch to the Thunderbird code early morning today. Thanks to Jeff Beckley for guiding me through submitting the patch. Hopefully it'll get a positive review/superreview. This fixes one of the bugs I mentioned in my previous post: edited (and new) drafts don't have their corresponding files generated automatically. There's one other nagging bug to fix: trash messages when deleted don't have an itemDeleted notification called.

Attachments handled

2008-05-07T21:41:00.009+05:30

I've been able to filter attachments, using the multipart definition in RFC 1341. I've implemented it like this, in a quite rudimentary manner.

If the message flags indicate that the message has an attachment, I'll look for the first "\r\nContent-Type: " header. Immediately following it will be a "boundary=" line, after which comes the multipart boundary (this may or may not be in quotes). A sample message (generated by Tb itself) has this:
```
Content-Type: multipart/mixed;
 boundary="------------070607000408050100040102"
```
I extract the boundary, and trim whitespace and remove quotes.
I look for the first occurrence of the boundary, ignore it, look for the second occurrence, and remove that and everything ahead of it. (The first part is the juicy part, of course.)
I add the end boundary marker with surrounding CRLFs, as specified in the RFC.

UPDATE May 8: nsIMimeHeaders and nsIMIMEHeaderParam do the job in a cleaner and more RFC-compliant manner. This seems to be working for the most common type, multipart/mixed, where the first part contains the actual email. However, there are several other multipart subtypes. Out of these, I think only multipart/digest might be a problem (is it even used/supported by Thunderbird today?) Another potential concern is non-English messages (Unicode/codepages). I don't think they should be a problem, given that we are dealing with "normal" 7-bit characters in the boundary. I also noticed some bugs in the current implementation while testing out changes.

Drafts, once edited, aren't re-written.
Messages removed from trash don't have their correspnding files deleted.
Messages aren't written as soon as they are saved as drafts. They have to be opened before the file is written.

First steps

2008-05-06T21:33:00.005+05:30

So, I started working on my GSoC project today. The project (bugzilla link) has changed a bit since I discovered that Thunderbird's mbox format isn't thread-safe. So now the plan is to write out individual RFC822 files, and let the built in RFC822 parser parse them. The component is a Thunderbird extension right now. I've tested some basic output files (no attachments yet -- anyway I plan to filter attachments), and they are being parsed correctly by the parser. Update: The extension now starts up on application startup. Todo tomorrow: handle attachments, make sure it's a singleton (only one instance of the component is created!).

Google Summer of Code 2008

2008-04-22T11:41:00.000+05:30

So, I've been accepted into the Google Summer of Code 2008. I'll be working for The Mozilla Project. This should be fun. (I really doubt I'll blog too much, but I just might)