helvetica_10pt_bold = Helvetica(10, bold=True)

Helvetica is the typeface. “Helvetica 10pt bold” is the font.

Yes, I admit to having been an amateur typophile for a while now. It probably started with Donald Knuth, and me poring over his books in the Canterbury University library between lectures, just basking in pure letter shape.

Anyway, Helvetica is no longer just a Swiss typeface. It’s now also a feature-length documentary about the typeface and about graphic design in general.

It runs for 80 minutes, and it interviews a number of top type designers. Still, it’s certainly interesting for a general audience. My wife prepared herself to be bored, but actually found it quite compelling.

Another interesting thing is the Helvetica vs Arial debate (if you can call it a debate). Arial is pretty much a cheap clone of Helvetica, designed by Microsoft so they didn’t have to pay Linotype’s licensing fees. I don’t have to try too hard to believe that.

The differences between the two typefaces are very subtle, but interesting. Check out the differences in the ‘a’ and the ‘t’ in the image to the right. Mark Simonson has more on this.

Anti-Microsofting aside, I do prefer the font handling in Windows XP over anything else I’ve seen. It’s just so clear and sharp. Linux still doesn’t have it together. And even Mac OS’s fonts aren’t that great — Apple seems to be pretending we’ve already all got 300dpi displays.

So check out Helvetica, the film. I think you’ll enjoy it, typophile or not. At the least, it’ll make you do a double-take at every other sign and billboard — “Hey, is that Helvetica?”

For our own wedding, my wife and I got about 20 white platters, not to mention 3 toasters. I guess it’s nice to be able to give away toasters to the needy, but I wanted to save my friend the hassle. :-)

There are a bunch of wedding gift sites out there already, but they’re usually tied to a specific shop, or they cost US$99 to use. And some require guests to go through a long sign-up process — not cool.

Well, here is Gifty.co.nz. It wasn’t much harder to open it to the public, so I did:

It’s simple and free to start a list, and it only costs NZ$20 (US$15) when you’re ready to send out your invites. Try out the demo list, or tell your friends that are getting married to head over to Gifty.co.nz.

Note that Gifty only does wedding gift lists at the moment, but I’m planning to add support for other types of lists before too long.

What protothreads give you is the ability to write procedural, thread-style code, but without the overhead of real threads. The kind of thing embedded programmers normally use switch state machines for.

The other alternative is full-blown threads, but real threads certainly have their drawbacks. They each need their own stack, for one — and that’s often nasty in embedded systems, where you might only have 2 KB of RAM total. There’s the performance hit of context switching. There’s having to worry about sharing between threads, locking, etc.

Enter protothreads.

One of the cool things about them is that, behind the scenes, they break all the conventions (but not the commandments). Use of the legendary Duff’s device, macros that open braces but don’t close them … but they work, they’re fast and portable, and they give you pseudo-threads almost for free.

Because of how they work — perhaps it’s the same for any neat tool — there are a few gotchas:

• You can use locals, but their values won’t be remembered across waits (you have to use statics for that).
• You’ve got to put all your “state change code” in a single function.
• And you can’t have a switch of your own spanning the use of the wait macros.

You’ll want to read more about them and see some examples on Adam Dunkels’ website.

Protothreads in C++

But what about this C++ thing? Well, C++ is a more or less a superset of C, so protothreads will work as-is. But if we take C and sprinkle in a dash of ++, we can make them even tastier:

• You can make a Protothread class, so you don’t need to pass the struct pt* around everywhere.
• You can use instance variables where you might have used statics, making your protothreads easy to multi-instance.
• You can write classes derived from Protothread that add helper variables and macros to read and wait for timers, specific I/O ports, etc.

“Okay, so show us an example.” Fair call.

Below is a C++-style protothread that implements a simple packet protocol. Each packet has a sync byte, a length byte, n data bytes, and a checksum byte. Packets are only processed if they’re good and complete:

bool UartThread::Run()
{
    PT_BEGIN();

    while (true) {
        // wait for sync byte
        PT_WAIT_UNTIL(ReadByte(ch));
        if (ch == Sync) {
            // read length byte, ensure packet not too big
            PT_WAIT_UNTIL(ReadByte(ch));
            len = ch;
            if (len <= MaxLength) {
                // read n data bytes
                for (i = 0; i < len; i++) {
                    PT_WAIT_UNTIL(ReadByte(ch));
                    data[i] = ch;
                }
                // read checksum, dispatch packet if valid
                PT_WAIT_UNTIL(ReadByte(ch));
                if (ValidChecksum(data, len, ch))
                    Dispatch(data, len);
            }
        }
    }

    PT_END();
}

Not bad, eh? Even with comments it’s much shorter and sweeter than the equivalent state machine version (which, incidentally, is pretty much what the protothread macros expand to):

bool UartThread::Run()
{
    while (true) {
        switch (state) {
        case StateSync:
            if (!ReadByte(ch))
                return true;
            if (ch != Sync)
                break;
            state = StateLength;

        case StateLength:
            if (!ReadByte(ch))
                return true;
            len = ch;
            if (len > MaxLength) {
                state = StateSync;
                break;
            }
            i = 0;
            state = StateData;

        case StateData:
            while (i < len) {
                if (!ReadByte(ch))
                    return true;
                data[i] = ch;
                i++;
            }
            state = StateChecksum;

        case StateChecksum:
            if (!ReadByte(ch))
                return true;
            if (ValidChecksum(data, len, ch))
                Dispatch(data, len);
            state = StateSync;
        }
    }
}

So there you go. I know which version I’d rather write and maintain.

Feel free to use the Protothread.h header file I put together from Adam Dunkels’ C version — it should have all you need to get started. I’ve left a “protothread scheduler” as an exerciser for the reader, as it would be both simple and application-dependent.

Just a final word: I’m not suggesting protothreads are a replacement for threads — they’re not. But when you need the appearance of threads, or you’re dealing with embedded micros and don’t have screeds of RAM, give them a try.

Chris Woods has also implemented a version of protothreads in C++, but he’s taken a different approach for the Symbian OS.

Step one: turn off the “are you sure?” dialog. What’s the point in having a confirm dialog if you can easily get the files back from the Recycle Bin anyway?

To turn it off, go to Explorer (the file browser, not the web browser), then right-click on Recycle Bin and go to Properties. Simply uncheck the option “Display delete confirmation dialog”, and you’re away.

You can then press delete, and it’ll delete right away. If you stuff up and really do want that file, it’ll be there for you in the Bin.

Step two: use “Undo Delete”. Actually, it’s easier than the above. Explorer has a nice Undo Delete action. If you’ve just deleted a file but didn’t mean to, simply go to the Edit menu and click Undo Delete (even better, just press Ctrl-Z, the standard undo key).

For starters, version 8 was a 22 MB download. Version 9 is a mere 33 MB — a whole major version up, and not even twice as big. The default download includes a 19 MB eBay Desktop program, for all your “faster searching, smarter bidding” needs. So tempting … but I opted out.

On my cable connection, it took about 5 minutes to download, nicely allowing me enough time to brew a decent cup of coffee while I waited.

But it wasn’t just a simple, ordinary download. First Adobe told me to download a Firefox plugin. I assumed the plugin would help me read PDFs in my browser. But oh no, this was a special plugin, an Adobe Reader Download Manager (TM) — a plugin specially designed to help Firefox download Adobe’s powerful PDF viewer.

After the plugin was installed and Firefox restarted, the download began. I couldn’t wait to try Adobe’s MUCH FASTER and SMARTER product.

Download done, I double-clicked the installer. It spent a long time unpacking and validating the installer, which gave me warm fuzzies about Adobe’s good grasp of stability, security, and enterprisey robustness.

After the unpacking, the install process itself took 10 minutes. I could only thank Adobe’s engineers, presuming they were filling up my hard drive with yummy icons, tasty DLLs, and amazing 3D JavaScript add-ons. No matter — the 210 MB it required was there to be used.

I had just slurped down the dregs of my coffee when the installer finished. I was so thankful when it told me I needed to restart my computer, welcoming the extra time to drink coffee, as well as the pure delight I knew I’d get from starting all my applications again.

I could finally try out this new software. I was impressed. It started in a minuscule 13 seconds, plus the time it took me to skim their poetic and beneficent license agreement.

Ah, the joy of using a new product. Unlike Microsoft products, Adobe’s new, bigger Reader behaves exactly the same as the old one. In fact, it’s so compatible I can’t even tell the difference! Boy, I know good release management when I see it …

Thank you, Adobe, for version 9 of your free PDF Reader. You even thought to put a nice link to Acrobat.com on my Start Menu!

I’m not just talking about memory and megahertz bloat — we’ve also got performance unbloat. And it almost seems like the two go hand-in-hand. The more memory something hogs, the slower it’ll run.

Compare Foxit’s PDF reader to Adobe Reader:

• Foxit is a 2.5 MB download, Adobe is a 25 MB one.
• Foxit uses 8 MB of memory for a 700 KB PDF, Adobe uses 56 MB.
• Foxit loads in about 1 second, Adobe in 4 seconds.
• Foxit is as fast or faster to use.

Okay, so maybe Foxit doesn’t display all the latest 3D JavaScript-enhanced PDFs, but it does all you need, and it does it (relatively) small, fast, and light.

Maybe it helps (or hinders) to be an embedded programmer, and know how much you can do with 32 KB of code, 2 KB of RAM, and an 8 MHz, 8-bit processor. Sometimes I wish developers had to write code on ancient 66 MHz 486s. Constraints are the mother of optimization, and programmers will usually forget about optimization after it runs “fast enough” on their 42-core Pentium IX, 10 TB RAM development machine.

Sure, I grant that RAM and clock cycles are cheap these days, and we might as well use ‘em. But surely there’s a limit to all this. When my (plain text!) editor runs slow enough so I can see the screen updating, there’s something wrong.

When Visual Studio takes 2 entire seconds to pop up a simple properties window the first time, there’s something wrong.

Back in the days when programmers cared about how many characters they could write to video memory during the CGA horizontal retrace time without it producing snow — back in those days, and running on a 286, I couldn’t see my screen updating.

We now have 1000’s of times the computing power, and as far as user experience is concerned, stuff runs slower than it used it. And we put up with it, because they’ve added one or two features we like, and it’s “good enough”. But it just ain’t right.

And it’s not just the my text editor and Visual Studio. When Thunderbird first came out, it was so slow on my fairly average hardware that I simply couldn’t use it. And now on my 2 GHz dual-core whatever-it-is, it’s still slow. I click on Inbox the first time, and it takes a second and a half for the message to pop up. Come on, people — you could load a usenet thread off a floppy drive in that time!

Somehow we’ve convinced ourselves that Gmail’s conversation view and anti-spam features make it worth putting up with 750 millisecond Ajax delays all the time. Nope, it just ain’t right.

Recently I was reading from Michael Abrash’s Graphics Programming Black Book, and he has something telling (albeit provocative) to say about all this in chapter 2:

You will notice that my short list of objectives for high-performance assembly programming does not include traditional objectives such as easy maintenance and speed of development. Those are indeed important considerations— to persons and companies that develop and distribute software. People who actually buy software, on the other hand, care only about how well that software performs, not how it was developed nor how it is maintained. These days, developers spend so much time focusing on such admittedly important issues as code maintainability and reusability, source code control, choice of development environment, and the like that they often forget rule #1: From the user’s perspective, performance is fundamental.

My theory is that it’s gonna take an RMS-style prophet to come along, take a few pages out of Abrash’s book, write his own instant-GUI operating system, wake up the masses to the joy of responsive computing, and watch the bloat industry crumble.

It’ll be a world where you can turn on your computer and use it immediately. A world where you wait at most half a second for big programs to load. A world where your screen will update even before the keyup event is sent. It won’t be utopia, but I’m still looking forward to it.

We’re taking submissions for this kind of prophet. Drop your résumé or CV in the comments below. :-)

For more about “crowdsourcing”, see the Wikipedia article on the subject.

For instance, I often use USB-serial devices, and when I need to check which port one of them’s attached to, here’s the 7-stage clickfest:

1. Start
2. Settings
3. Control Panel
4. System
5. Hardware
6. Device Manager
7. Ports (COM & LPT)

Well, it can be much simpler than that. Simply put the following lines in a file called ports.bat and drag it to your quick launch bar:

reg query HKLM\hardware\devicemap\serialcomm
pause

Voila! Every time you click it, you get a nice list of all your COM ports in Lucida Console.

Feel free to drop your own XP developer tips in the comment box.

if y < 32:
    x = (y << 3) & 0xFF

you have to write

if y < 32:
    x = (y << 3) & 0xFF

Please, no!

Admittedly, it wouldn’t be hard for them to have their back-end convert these characters to HTML entities if they’re inside a <pre> tag. But then you can ask, is it really HTML anymore?

And would it correctly interpret “if n<pre: x >>= 3”?

Even apart from all that, however, I much prefer the simplicity and relative beauty of a good markup language (read: Textile or Markdown). And it’s hardly a learning barrier if you’ve got a pop-up “help window” nearby, like reddit or this blog do (see “formatting help” below).

The word’s just got a ring to it.

Yeah, pretty decent.

It’s like, totally way better than Cool. Same meaning and all that, but without those frigid “as a cucumber” connotations. Plus, it’s got a much bigger moral and artistic backbone.

Trust me, all the decent people are doing it. All the people here, at my place. Well, I am, at any rate. Woke up one morning and just switched. Easy as s/cool/decent/g.

Chesterton said we should break the conventions but keep the commandments. So why not start with your lingo, blingo, rap rap, you know what I’m sayin’?

C’mon, join the revolution: bring decent to a town near you.

Decent, man.

P.S. Yep, I’m afraid this is tongue-in-cheek. Though I have “switched” — and years before DecentURL was conceived. Then again, maybe it’s just getting late. :-)