I just found a little gadgety program for Windows named Y’z Shadow: all it does is add a little shadow effect to your windows (similarly to Mac OS X’s window shadow). While it sounds gimmicky, it’s amazing just how much difference a little shadow makes in distinguishing one window from the next. Try it out and see if it makes window management just that little bit easier for you!

Update: It looks like the YzShadow link above is dead, but you can appear to download it from at least one other website.

Paul Graham has a new article titled How to Start a Startup, which is an excellent article for hackers who are interested in business. There’s lots of gems in there, but I particularly liked this one:

It’s worth trying very, very hard to make technology easy to use. Hackers are so used to computers that they have no idea how horrifying software seems to normal people. Stephen Hawking’s editor told him that every equation he included in his book would cut sales in half. When you work on making technology easier to use, you’re riding that curve up instead of down. A 10% improvement in ease of use doesn’t just increase your sales 10%. It’s more likely to double your sales.

Maybe Graham can get through to hackers where Jakob Neilsen and other usability experts have failed. That one paragraph is a concise summary of a point that Neilsen has been trying to advocate for years: spend the time and money on improving your software’s usability, and it’ll turn out to be a net profit.

Boring summary: the ever-entertaining Jamie Zawinski talks about why groupware is stupid.

Fun summary: Jamie Zawinski vs Nat Friedman, awesome JWZ-style swearing throughout the article, paying out on stupid managers, and, as usual, telling us how crap Netscape went from version 2 to version 4.

(Props to Joel on Software for pointing out the article.)

First, new blog category: “Books”. Go me. One of my New Year’s promises was to read more (fiction) books. Well, it wasn’t really a New Year’s promise — more of a general promise I’ve been wanting to keep to myself for about the last 5 years, so hopefully blogging about it will bring my non-book-readingingness out of inertia.

Anyhoo, the subject of today’s bookdom is Consider Phlebas by Iain M. Banks. If you like big, grand, massive sci-fi scales and plots, this should float your boat quite nicely. The back-page summary of “a space opera of stunning power and awesome imagination” fits it very nicely. If you’ve ever played the magnificent computer game Freespace 2 and gaped in awe at capital ships which are kilometres long and supported thousands of crewmembers, this book evokes the same feeling — only several orders of magnitudes more epic. The main character, Horza, is interesting and is fleshed out quite well, and the supporting cast are decent too. Banks’s universe is filled with great, non-boring detail, from the philosophies of the Culture to the concepts in the Damage gambling game.

To top it all off, the ending of the book is quite interesting, in that the extra “factual pages” at the end of the book give it a sense of closure, while not completely resolving the main plotline. You’ll have to read it to understand what I mean, I suppose.

It’s not a thought-provoking kind of novel like the Ender series is, but that’s not a bad thing considering it clearly never has that goal in mind. If you want serious thought-provoking material, I’ve heard that some of Iain Bank’s numerous other books are quite the hardcore sort. (i.e. At least one person I know simply can’t read his other books simply because they’re so … grim.) As for Consider Phlebas, I loved it. I haven’t read an excellent epic sci-fi tale in a very long time. Recommended.

A man named Peter Maurer has published a most excellent bit of software for the Mac named Witch. Witch is a window switcher, in the spirit of LiteSwitch X in the pre-Panther days. I quite like the standard ⌘-Tab window switcher that’s built into Panther, so I won’t be using Witch for that. However, Witch’s killer feature for me is that it can also replace the ⌘-` key with its own switcher, which works in a MRU (Most-Recently-Used) fashion, similarly to how ⌘-Tab works.

Witch’s standard ⌘-Tab window switcher replacement also cycles through all documents in all windows, rather than only cycling through the active windows, which is gives more Windows-like behaviour if you prefer that. It also has other nifty features like being able to assign window zoom/minimise to keyboard shortcuts — but IMHO, that’s all small candy compared to the excellent ⌘-` document switcher replacement!

Coders of the world rejoice, for Martin Pool is building a distributed revision control system:

I am not working directly on Ubuntu, but rather on improving the tools used by open source developers inside and outside of Canonical. The charter is to build a distributed version-control system that open-source hackers will love to use.

Knowing Martin, this will have the usability of Subversion and Darcs, the algorithms of Arch, and the pure leetness of rsync. Beware, other RCS authors: your days are numbered!

I just wanted to make a short comment to say how absolutely awesome the tennis in the Australian Open has been this year. The level of play is fantastic and the competition has been great (a crazy number of five-setters!). I don’t ever remember an Australian Open which has been this good. I only wish I were in Melbourne!

Mmm, I want one of these (never mind that I already have a 1GB SD card and a tiny 1GB USB flash drive):

SanDisk has today announced a unique SD card which has a hinged portion, flip this over and the card becomes a USB 2.0 Flash Drive. This neat piece of engineering means that you can flip the card out of your camera and straight into your computer without the need for any card readers or cables. Clever. SanDisk expect to be able to produce this new card in capacities of up to 1.0 GB, they will have more detail and initial samples at the upcoming PMA 2005 show.

I found an excellent webpage about Win32 calling conventions when I had the pleasure of writing a C++ Apache 2 module. If you’re a UNIX guy who’s learning to deal with anything that involves both C and C++ on Windows, and you’re getting stack dumps which just does not make sense, it could be a calling convention problem. If you don’t think that’s too bad, just wait until you have to write typedefs and use type casts which involve calling conventions! (C’s typedef syntax seriously needs a kick in the nuts.)

If you’re like me and have about 100 files sitting in your Safari downloads folder, have a look at DownloadComment:

When you download things in Safari, DownloadComment will put the original URL into the saved file’s Finder Comments. Now you’ll always know where your downloads came from.

Cmd-I in Finder to display the file comments, and BAM! Instant reminder where on earth you got that file from and why. I’ve been using it for less than a week, and it’s already proven itself useful.

And the Linux Kernel Patch of the Week award goes to …

Jake Moilanen provided a series of four patches against the 2.6.9 Linux kernel [story] that introduce a simple genetic algorithm used for automatic tuning. The patches update the anticipatory IO scheduler [story] and the zaphod CPU scheduler [story] to both use the new in-kernel library, theoretically allowing them to automatically tune themselves for the best possible performance for any given workload.

Whether it really is truly effective will only be seen, but the coolness factor is so there …

Hmm, so Guido’s blogged even more about adding static typing to Python. I’m not sure if that’s a good idea. While I’m certainly a static typing evangelist, Python has always been a dynamic language, and shoe-horning a static type system on to a language which was never designed for it sets off alarm bells in my head. Objective-C deals with ‘static typing’ quite nicely: you get compiler warnings if the types don’t match. This doesn’t limit any of its dynamism, but you get some extra safety if you decide to use types in your program. Patrick Logan doesn’t like Guido’s proposal either, although that’s no surprise.

So, Python might just get static typing in the future. What’s next, Haskell getting more dynamic?

This is gold:

Mr. Jobs, please establish eligibility requirements for the purchase of a new Mac. A good start would be to disqualify anyone who listens to Ashanti or anything they play on K-Rock.

I was thinking of writing a parser combinator library for C++ today so that I could write a C++ parser in a style similar to using Daan Leijen’s awesome Parsec Haskell library. Then, I came across Spirit, part of the excellent C++ Boost libraries. Of course, they’re advertised as template-based parsers rather than parser combinator-based parsers, since C++ programmers will go blank in the face when you say ‘parser combinators’. If you’re not familiar with parser combinators, here should be all the motivation you need for using Spirit, from its introduction page:

A simple EBNF grammar snippet:

    group       ::= '(' expression ')'
    factor      ::= integer | group
    term        ::= factor (('*' factor) | ('/' factor))*
    expression  ::= term (('+' term) | ('-' term))*

is approximated using Spirit's facilities as seen in this code snippet:

    group       = '(' >> expression >> ')';
    factor      = integer | group;
    term        = factor >> *(('*' >> factor) | ('/' >> factor));
    expression  = term >> *(('+' >> term) | ('-' >> term));

Mapping an EBNF directly on to the language syntax: ahh, so good. If only more people realised that the whole embedded domain-specific language approach is so nice!

Well, here’s something I had absolutely no idea existed before today: you can add your own custom screen resolutions with NVidia’s video drivers.

• Control Panels -> Display Properties -> Settings tab -> Advanced button -> your nvidia chipset tab

• Select the Screen Resolutions & Refresh Rates menu item on the ‘drawer’ next to the dialog box

• Click on the Add button, and add away.

This is great for those monitors which can’t quite push it to 1600×1200 comfortably (e.g. being either too blurry or just having too low a refresh rate at such high resoutions). I’m running my old-ish 21” CRT at 1400×1050 now at 85Hz: quite a decent amount more desktop real estate than 1280×1024, with a refresh rate where I won’t be tearing my eyes out. Nice.

Which File Extension are You?

Aww jeah, I gotta have me one of these. And it’s even accompanied by the most impressive advertising I’ve ever seen for a mouse. (I particularly like the “see the scroll panel in action” demo. Look at that spreadsheet fly!)

The propellerheads at Lambda have an interesting discussion that started with RDF (at least, interesting if you’re already familiar with RDF)), and evolved to discussing not only RDF, but also the semantic web, data schema, and ReiserFS and file systems.

A nice quote I found from a comment on Slashdot:

Languages like OCAML and Java are defective as general purpose languages because they don’t support efficient data abstraction for numerical types. The fact that their designers just don’t get that fact is a testament to the ignorance of their designers. It’s also what people really mean when they say that those kinds of languages are “just not efficient as C/C++”: it means that in C/C++, you can get whatever code you write to run fast, while in OCAML or Java, there are always problems where you have to drop down to C.

I’ll insert the usual “I agree” here. This is especially a problem with language benchmarks, which typically have benchmarks that operate on huge numbers of tiny bits of data. This usually destroys any chances that a functional language has of competing with a very low-level language like C/C++, because often these big arrays are represented as a series of pointers to the actual data, rather than simply big arrays that directly contain the data. This means one more pointer indirection for every index operation in the array, blowing away your cache hits and thus making your program run several orders of magnitudes slower. (If your language is also lazy, like Haskell is, you basically cannot work around this performance restriction unless you make your data structure strict … in which case, well, you’re not using laziness any more.)

This problem needs to be solved, without forcing the programmer to spend lots of time annotating exactly what data structures should be unboxed and what should be boxed, and what functions are OK to work with unboxed/strict data structures. Otherwise, people just aren’t going to these other languages for processing large quantities of small data. And in this day and age of computing, processing large quantities of small data is required for quite a lot of applications …

There’s also some interesting comments about Python 2.4’s new generator expressions, and how they are similar yet different to lambda expressions/anonymous functions: in particular, how they appear to give rather nice performance benefits. I haven’t given generators too much thought at all yet, assuming they were less elegant, ad-hoc implementation of representing lazy data structures. Sounds like I have some investigation to do!

If you’ve got a weird graphics corruption problem when you try to play Frozen Bubble on Mac OS X that looks like this:

Try downloading my patched version of Frozen Bubble which fixes the problem.

Note to hackers: the patch to fix the problem is pretty trivial …

diff -Nru Frozen-Bubble (Original).app/Contents/Resources/__main__.pl Frozen-Bubble.app/Contents/Resources/__main__.pl
--- Frozen-Bubble (Original).app/Contents/Resources/__main__.pl	Thu Jan  1 06:12:48 2004
+++ Frozen-Bubble.app/Contents/Resources/__main__.pl	Sun Nov 28 23:00:13 2004
@@ -1679,12 +1679,8 @@
 	generate_new_bubble($PLAYERS[1], $next_bubble{$PLAYERS[0]}->{img});
     }
 
-    if ($graphics_level == 1) {
-	$background->blit($apprects{main}, $app, $apprects{main});
-	$app->flip;
-    } else {
-	fb_c_stuff::effect($app->{-surface}, $background->display_format->{-surface});
-    }
+    $background->blit($apprects{main}, $app, $apprects{main});
+    $app->flip;
 
     $display_on_app_disabled = 0;
 

I have no idea why the fb_c_stuff::effect there is screwing things up so badly; I suspect it’s either a problem with SDL for Mac OS X, or Frozen Bubble’s fb_c_stuff.xs Perl/C code. Furthermore, it only doesn’t work on some Macs I’ve tried (my 1GHz TiBook/Radeon Mobility 9000, and Michelle’s 800MHz iBook G4). Some Macs work OK, some Macs don’t. With the patch, all Macs work OK. Beats me completely. I’ve emailed the Frozen Bubble for Mac OS X maintainer to see if he can dig around a bit to find out why it’s causing such a ruckus …

Update: The official Mac OS X port has now properly fixed the graphics corruption bug as of version 1.0.0e, so this patch is now redundant. Go grab the new version!