Out of Hanwell

The Fusion beta is out! And now I’m off to download it and a Kubuntu image.

After reading Douglas Crockford’s for in Intrigue, I could help but write this function:

Object.prototype.hasOwnProperty = Object.prototype.hasOwnProperty || function(prop) {
return this[prop] !== arguments.callee;
};

It’s useless in its own recursive way.

Oh yeah, and it’s also still verboten.

Today I was looking for a faster way to quickly sort my e-mail in Thunderbird. Up to now, I’ve been selecting and dragging all messages to an archive folder after I’ve read them and taken appropriate action. However, that’s cumbersome. Today I found the QuickMove Extension, which allows you to move messages into specific folders using the Ctrl+1 through Ctrl+9 hot keys.

Unfortunately, this extension doesn’t work in Thunderbird 1.5. To install, you need to:

1. Download the extension.
2. Rename it to a .zip file.
3. Change maxVersion to 1.5+ (or your current Thunderbird version).
4. Rename it back to a .xpi file.
5. In Thunderbird click Tools, Extensions, Install and locate the .xpi file to install it.
6. Restart Thunderbird.

You can now set up your shortcut keys by choosing Message, Set QM Options.

Silence is a difficult answer.

The Internet Explorer team is clearing house on the bug reports. Tonight I received a noticed that I should revalidate several bug reports on RC1 and re-open if necessary. I responded with a comment saying that these bugs still exist in RC1, but to no avail. About half an hour later, they closed the job.

I certainly can’t blame them for wanting to close out old bugs, but what do they expect me to do? Am I really supposed to file a new feedback item for this problem? If so, can’t they provide some way of retrieving the attachments from the original item to expedite the process? After all, Microsoft Connect was designed to allow Microsoft to interact with its user base.

“Can you hear me?”

It’s not just the IE team. E-mails to which I would previously have promptly responded now languish in my inbox. Feature requests that I would have coded within several days now rest in the issue tracker or remain partially implemented on my computer. Crashes remain unfixed for a week after test cases have been created. My blog sits dormant.

“Can you hear me?”

Alas, the problem is not silence but clamor! A million things yell for attention, and only that which yells most loudly receives it. That’s how Microsoft can seem so silent, and (unfortunately) how I can seem so silent.

Fixing bugs. Creating tests. Writing new features. Discussing software design. Submitting patches. Compiling libraries.

“I found a bug!”

“CAN YOU HEAR ME NOW?”

I’ve often thought about and wished for an editor that’s browser-based, multi-user, real-time. It looks like Neil Fraser beat me to it with MobWrite (with demo). This would be a great tool for remote design discussions, code reviews, or training. Neil also has written a number of articles on Diff Strategies, Fuzzy Patch, and Differential Synchronization.

I can’t wait to see where this goes. Here’s what I’d want:

• syntax coloring
• attribution of changes (who did what?)
• visual timeline (what did it look like 10 minutes ago?)

I’m off to install this on one of my computers.

Update: I did have a chance to try this out today, but it started producing mysterious “ghost” edits. I’m still sold on the idea, though.

I have often wondered, “What marks intellectual maturity?” One thing is clear: the ability to reason, even when the “correct answer” is unknown, sets apart an adult from a child. How many times were you frustrated by an essay question in grade school because you didn’t know what the teacher wanted?

I now realize what I didn’t understand then: You can learn a lot through rote memorization. But when it comes to making dependable decisions, you’re going to need more than just that. Today, although I’m interested in other people’s opinions, I’m even more interested in their reasoning.

Why?

Reasoning is reusable.

My best example comes from my profession. My boss and I were once discussing our reporting feature, which I had implemented incorrectly. Whenever you wanted to modify the report (change the title, add a column, etc.), you had to save the report to file before viewing your changes. My boss, however, told me that doesn’t work–the user needs to be able modify reports and run them without saving.

That could have been the end of the conversation. But it wasn’t. Rather, he immediately had a business reason defending this. During a sales demonstration, users often ask, “Can this report show this piece of information?” When the salesperson adds the column, it’s quite distracting to save it, especially if you need to specify where and how it should be saved! The ease evokes an oh-wow-that’s-easy response. And it’s not limited to sales, either. When people modify reports, they frequently only want to tweak it slightly. Saving their report is only a distraction from their goal, which is analyzing information, not building reports. What could have simply have been a statement of opinion was instead an explanation of the reasoning. Rather than fixing this single inconvenience, I was now equipped to look for other problems that kept the user from his or her task.

It’s worth something to have a programmer read your mind during the interview, but there’s a lot to say about a programmer who solves a problem in a suboptimal way but is able to defend his decision. That he’s thought through the reasons is a good sign. That, I think, clearly marks intellectual maturity.

A JavaScript Lint user recently pointed out that JavaScript Lint does not support the following code:

function window.onload() {
window.alert('Hello World');
}

Surprised, I pointed out that this is invalid JavaScript. However, it turns out that Internet Explorer supports this unusual syntax. Internet Explorer allows this on any object:

var foo = {};
function foo.bar() {
window.alert('Hello World');
}
foo.bar();

It also allows this:

function Foo() {
}
function Foo.prototype.bar() {
window.alert('Hello World');
}
var o = new Foo();
o.bar();

Just for fun, I tried this, which it refused:

function Foo() {
function this.bar() {
window.alert('Hello World');
}
}

It also refused this:

function foo['bar']() {
window.alert('Hello World');
}

Does anybody know where, if anywhere, this is documented?