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?

I used my notebook quite heavily for terminal services, so I was quick to download Microsoft’s Remote Desktop Connection Client for Mac when I got my MacBook. However, it was quite slow even at low color depths. One evening I tried using it to code, but it was very unproductive. After that, I used it mostly to check e-mail. I finally decided to see what it takes to install rdesktop.

Although it took a bit of time to set up, I was very glad I did. It’s very fast and very useable, and it certainly beats Microsoft’s client. I have documented, as best I could, the steps required to set up rdesktop. I apologize in advance for any mistakes. But let me tell you, it’s well worth it!

Getting It Installed

1. Find and insert your Tiger installation CD.

2. Using the Finder, locate the Xcode Tools package and install it.

3. Open the Terminal and run the following command to install X11:

   open /Volumes/Mac\ OS\ X\ Install\ Disc\ 1/System/Installation/Packages/X11User.pkg

4. Download the latest stable version of rdesktop (1.4.1 at the time of this post).

5. Assuming you downloaded the package to your desktop, run the following commands in the Terminal:

   cd ~/Desktop
tar xzf rdesktop-1.4.1.tar.gz
cd rdesktop-1.4.1
./configure && make && sudo make install

   Once that’s done, you can delete the extra files from your desktop.

6. You should now be able to open X11 from your finder and run rdesktop with the following command:

   /usr/bin/local/rdesktop 192.168.0.255

Fixing the Alt Key

When I first ran rdesktop, I found that the alt/option key did not map as I expected. The solution is simple:

1. Create a file called ~/.Xmodmap with the following contents:

   clear Mod1
keycode 66 = Alt_L
add Mod1 = Alt_L

2. Open X11 preferences (Cmd+, from X11) and disable “Use the system keyboard layout”.

Streamlining It Further

Although this allowed me to use rdesktop to connect to my computer, it was still too much work, so I decided to streamline the process a bit.

1. Create a file ~/rdesktop-mycomputer.sh with the following contents:

   #!/bin/sh
/usr/local/bin/rdesktop -f -a 16 192.168.0.255

2. Run the following command from the Terminal:

   chmod +x ~/rdesktop-mycomputer.sh

   You should now be able to run open-x11 ~/rdesktop-mycomputer.sh to open rdesktop in X11.

3. Unfortunately, xterm gets in the way when you want to use full-screen rdesktop. To keep it from launching, run the following command:

   cp /etc/X11/xinit/xinitrc ~/.xinitrc

   Then, using a text editor, open ~/.xinitrc and remove the line that reads “xterm &“.

4. Finally, open the Finder, Applications, AppleScript, Script Utility and create a new script with the following code:

   do shell script "open-x11 ~/rdesktop.sh &"

   Save the script in the “application” file format in a convenient location, such as your desktop.

5. You’re done! You should now be able to launch your rdesktop session with a single click!