small medium large xlarge

High Fidelity

So you want to listen to the latest Spice Girls recording?

Well, maybe you’ll want to put together a music system worthy of the
task. You might spend several months reading the HiFi magazines and
lurking on newsgroups before deciding on a preamp, amplifier, digital
Dolby, speakers, and turntable (after all, nothing sounds as good as
vinyl). The guy at the store mentions you’ll need 18-gauge
gold-plated cables to connect it all together. You bring it all home,
then spend days worrying about the placement of the speakers—good
listening area, proper distance from the wall, just enough deadening
(Did the latest repositioning really make a difference?). Nine
weeks after starting, you clean the record, spray on an anti-static
mist to stop dust from clogging the grooves, and slowly, slowly, lower
the needle. The anticipation is glorious as the needle gently but
inexorably spirals in towards the first track. You hold your breath.

Or, you could just slap the CD into your boom box.

The Ears Have It

Which is better?

To a true audiophile, nothing short of a custom-built, component-based
audio system will do. To the average Joe, who doesn’t want to be
bothered with all the messing around, the boom box is fine. There’s a
difference in quality, to be sure, but it’s a trade-off for
convenience, a trade-off that most people are happy to make.
Audiophiles look down their noses at the integrated system crowd, but
the vacuum tubes in their power amplifiers are still warming up while
the CD set is halfway through track three. It’s a trade-off. There
really is no single "better"—it depends on what you want.

It’s the same with many of the technical choices that face us in
computing. Assembly language gives me the ultimate control, but I can
slap together an interface in VB or Smalltalk in an hour or so. An
editor and Makefiles let me fine-tune my build environment, while an
IDE shields me from the messy details of compiling and linking.

Maybe one of the biggest rifts in the newsgroups right now is
Microsoft Windows versus Linux. And most of the acrimony starts from
the Linux side (if for no other reason than most Windows users have
never heard of Linux). Anti-Microsoft feelings run high, and are
expressed vehemently. Microsoft products are unreliable, they say.
Microsoft systems have lower performance, lower availability, fewer
tools, worse connectivity, and poorer configurability. Microsoft is
responsible for all the computing world’s ills. Everyone should
immediately switch to a Linux-based desktop.

Harmonic Distortion

What seems to offend the madding techie-crowd most is that Microsoft
products aren’t technically as good as (say) Linux or BSD. Like the
boom box compared to component hi-fi, Windows is basic, integrated, and
lacks configurability.

So what?

Just as no one seriously writes review articles comparing $100 boom
boxes to $5,000 hi-fi systems, people should get over this idea that
you can compare Windows and some flavor of Unix. The two systems are
designed for different audiences, with different objectives, and
different expectations. Unices come from a background of serious
applications, in high-availability, high-load server environments.
Unix systems are expected to be networked, and networked hard. In the
Unix world, the application takes center stage, and user interfaces
are relegated to the cheap seats. Unix systems are not used, they are
administered. Unix was never aimed at a mass market.

Windows has different objectives. Windows is a computing appliance,
where the technology is driven by marketing. Windows is oriented
around the user interface, not the application. This is its strength,
and historically the cause of its weaknesses. Windows looks good, and
when you stick within its domain, it can be easy to use. For a
lowest-common-denominator system, the technical folks at Microsoft
actually set the bar fairly high. The ability of COM components to
interoperate and contain each other is admirable—Unix boxes are only
just beginning to catch up with this at the User Interface
level. Windows configuration (while frustrating at times) can be a
snap. It took me 2 minutes to get my ’95 box dialing into my ISP; with
my Linux box I had to write a chat script, two shell scripts and
recompile the kernel.


I don’t think Windows is a particularly good system, but, like growing
old, it’s better than the available alternatives for 90% of the users
out there.

It’s just that, personally, I’m not one of that 90%.

For me, the Windows architecture gets in the way. The monolithic,
closed-box design stops me from configuring my environment the way I
need. GUIs that insist on repackaging the underlying data model stop me
from manipulating that same data with other tools. Windows tools are
not orthogonal—if they weren’t designed to interact, they typically
can’t interact. This puts me at the mercy of other applications
developers—if I don’t want to work their way, I’m pretty much stuck.
This is probably the biggest single cause of the building
anti-Microsoft resentment among developers. As a breed, they dislike
being told how to work. It’s like the difference between Microsoft
Word and markup languages such as LaTeX and SGML. A benefit of Word is
WYSIWYG—What You See Is What You Get. The disadvantage is
WYSIAYG—What You See Is All You’ve Got. Everything is on the
surface. There’s no underlying model.

By contrast, the layered architecture of a Unix system, even at 20+
years old, still offers me flexibility and configurability. I’m more
productive as a result, probably by a factor of two or more. My code
is better, because I can write and use text manipulation tools to
eliminate duplication, build tools to integrate components, develop
filters to help with testing, and use some frighteningly powerful
editors to help me get it all in to the system in the first place. I
pay for all this, of course. I have to invest time learning my tools,
and spend time administering them, keeping them clean and sharp. I
consider this time well spent. It pays itself back in increased
productivity, but, more importantly, it keeps me close to the system.
I know how it works. When things go wrong, I know where to
look. I can code with confidence, because I’m coding deeply, not just
on the surface. Like Pirsig’s Zen motorcyclist, I care for my machine,
and it takes care of me.

So lets drop the petty, childish Microsoft bashing. Who cares that
Microsoft technology may not be ideal? Linux users hoping to unseat
Microsoft from the desktop stand about as much chance as Ferrari
owners hoping to displace General Motors vehicles. Let’s not waste our

Instead, let’s enjoy that fact that we have alternatives. We
can configure and reconfigure our environments as we need. We can
choose to use Windows when necessary, then switch to Linux or BSD
when we need to get down to business.

We can have the high-technology, high-complexity audio system for when
we want the best, and the boom box for the picnics.

Let’s use what we have, appropriately and wisely. Let’s try to get
over this “my operating system is better than your operating system”
game, and instead let’s think about what “better” actually means.