*scottstuff*

The hard-drive fairy just showed up at my office, and I’m not out of disk space anymore. A friend’s company was selling 600 160GB drives for $50 each, along with a few RAID cards and a few other odds and ends. I picked up 4 160 GB drives and a 3ware 7810 for cheap. Once I get home, that should give me around 450 GB of RAID 5 space. Since my biggest box at home right now has mirrored 60GB drives, this should be a nice step up :-). I’m going to replace the mirrored drives with the RAID set, and then move the smaller drives to other boxes that need the space.

I’m not quite sure what I’ll do with 1/2 TB of space at home, but it shouldn’t be too hard to fill up. I have around 40 GB of images from my D60 that I’m been archiving off to DVD, plus another pile of mail and other assorted data. I need to start backing my laptop up; I’m getting deeply afraid of it dying, and disks are far and away the cheapest (and fastest!) way to perform short-term backups.

I’m also thinking about ripping most of my DVD collection and throwing it onto the drives, and then putting the xbox media player on the xbox downstairs :-). Unless I’m mis-reading things, that should do video-on-demand quite nicely. Of course, I’ll probably have to add another xbox upstairs once that starts working, but that’s the price of progress.

Now if I could just find a decent guide to xbox modding. I mean, I can figure out how to get Linux on the xbox without a hardware modchip, and I can figure out how to get the XBMP on the box with a modchip, but it’s completely unclear if I can combine the two, and I don’t really want to lose an entire weekend to this little project.

Another Cisco IOS rant. Who designed the bizarre excuse they have for a configuration language? That’s a rhetorical question; obviously no one designed it, it just happened.

Today’s example: the syntax for ip nat pool. It needs a name, a netmask, and an address range. Unusually for Cisco, it’ll let you use either a traditional 4-byte netmask or a cidr prefix-length for specifying the netmask. Except, it won’t convert between the two, so it remembers it in whichever format you provided. Nice and consistent. The address(s) can be entered either on the ip nat pool line, or they can be left out, but if they’re left out you’ll be dropped into config-ipnat-pool config mode, where you can enter one or more address range pairs. If you enter one, then show config will show you the single-line form, if you enter more then one, then you’ll get the config-mode form.

Way to be consistent, guys. By itself, this isn’t too hideously nasty, but IOS is completely full of things like this. When faced with a choice, they not only took both forks, but added a mountain bike trail and maybe a passenger trebuchet, and then it keeps track of how you got to the far end. And, if you take the trebuchet, it keeps track of how many pieces you arrive in.

I try to be pragmatic, but sometimes I just can’t help it and try to pick up lost causes. I think the world would be a better place if computers were easier to maintain. Fortunately, I’m a server person, and the server side of things is actually a lot easier then the desktop side, at least for now.

Warning: most of my experience is with Linux and Solaris boxes in ISP-like settings, although I’ve done a fair bit of time in small non-computer-related businesses and software houses. I have no idea how much of this applies to Windows.

I’ve been thinking about server management for years. Sometimes, I’ve been paid for it, sometimes (like now), I’m paid for other things. I still can’t stop thinking about it, though. There has to be a better way to manage servers then we’re doing now. As I mentioned yesterday, I think I might have a solution for at least a few common cases.

Traditionally, there are two models for server deployment. Either the heavyweight model (deploy a small number of servers and run lots of services on each) or the lightweight model (deploy a lot of servers, and run a small number of services on each). One of the problems is that, at least for small services, the heavyweight model seems cheaper. Why buy 10 servers that are going to sit 95% idle when you could buy 2 servers and have them be 75% idle? Or even one server that’ll only be 50% full. What happens pretty much every time is that a couple of the services start conflicting with each other somehow–one needs perl 5.6 for something, while another needs 5.8. Or they need two different versions of the JVM. Or one needs a critical security upgrade that ends up killing another service. So, you keep tweaking things, and you (barely) keep everything running, largely by avoiding making changes. Except, when you avoid making small changes, you inevitably miss little security fixes and little bug fixes, and you drift further and further from the mainline of whatever OS you’re running. So, inevitably, you reach the “server event horizon,” where things have grown so complex and unmanageable that the only thing you can do is buy 2-3 new computers to replace your one big system, and then slowly migrate services off of the old box onto the newer box. Except you end up with a lot of implicit assumptions lurking, assuming that DNS and DHCP are on the same server, or that Apache and Mysql are on the same box, and it takes forever to untangle them. Even once that’s done, you’ll find out that people have hard-coded server names into applications deployed all over the company, and you’ll end up spending 3 months untangling your one heavy-weight server that seemed like such a good way to save money at the time.

Conventional wisdom says that the way out of this problem is virtualization. Instead of buying 10 small computers, you buy one or two really big computers, and then partition them in software, and then install the software that you would have installed onto the little computers onto the partitions of the big computers. Lots of vendors love this model; IBM’s whole Linux-on-mainframes push is based on it. There are a couple problems with it as I see it, though. First, you’ll end up paying a ton of money for virtualization hardware or software–VMWare wants at least $2,500 per server for their PC-based virtualization code; pretty much everything else else is more expensive. Second, you’re still left with a bunch of small general-purpose servers that you need to manage individually, even if they do happen to physically reside within a single box. There are also reliability issues, but I’m going to ignore them for now; in my experience, even cheap PCs running Linux rarely crash, and when they do it’s usually a bad power supply, a bad hard drive, or bad RAM. Spending more money on hardware gives you multiple power supplies, better RAID, and more redundant memory. Plus buggy virtualization software, but we’ll come back to that, too.

Fortunately, the open-source world is making progress. User-mode-linux (UML) is making a lot of headway. It’s included in Linux 2.6, although it still needs a few little patches for optimum operation. It seems to have a 30% speed hit in a lot of cases; sometimes that’s a problem, sometimes it isn’t. Using it, you can build a big Linux host server, and then run a bunch of little virtualized servers on it for free. Sounds nice? Sort of–you still have to admin a ton of little general-purpose boxes, but at least you’ve mostly solved the dependancy problem that killed us a few paragraphs ago.

The nice thing about Linux is that it’s so flexible. Unlike every other OS that I’m aware of, there’s no one environment that is definitively Linux. Instead, we have a herd of Linux distributions, ranging from Red Hat to Debian to Gentoo to “Linux From Scratch” all the way down to the mini Linux distribution that wireless access point vendors call “firmware.” There’s no real reason for a special-purpose DNS server to run a full Linux distribution, except that it’s usually less work that way. However, once we have a UML-based virtualization scheme in place, it can actually be easier to use specialized distributions then general-purpose ones. I mean, the hard parts of a distribution are generally the installer, the hardware handling, and the update code. With a virtualized server, none of that applies. There is no hardware, really (it all pretends to be the same), the installer is really just a script that copies a hard disk image into place on the host system, and the update system is even easier–just save the data and completely discard the old OS image. In an ideal world, the OS image would be completely read-only, with configuration settings and data kept outside of the server in a standardized format. Then, software upgrades are truly trivial–kill off the old server VM and start up a new VM using the old data.

This won’t work for everything, of course. It’d be horrible for big database servers, or frankly big servers of any type. In my experience, though, there are a lot more small servers then there are big servers.

The other nice thing about this scheme is that the virtual server images are simple to build and easy to trade. They’re not utterly trivial, but it’s easier to build a server image then to actually write the server software or or maintain a full-sized OS distribution. Given a standardized interface between the host OS and the server image (things like IP address, DNS server, hostname, logging, and all of the other little details needed to make a server run), there’s no real reason that you can’t swap between server images from different “vendors”, grabbing whatever best serves your needs.

I’m starting to build a framework for this, more details as I have time to write them down.

After reading the last note, I just wanted to mention that I really like Ruby. It’s an amazing little programming language. If you aren’t familiar with it, it’s sort of like a cross between Smalltalk and Perl. Which is to say, it’s very good at the sort of things that people use Perl for, but without all of the nasty syntax issues. It’s a fully OO language, unlike Perl or Python, but it doesn’t beat you over the head with it, unlike Java. Go play with it, you don’t know what you’ve been missing.

I’m not sure what it means when you’re surprised when a GUI toolkit actually works. I suspect it means that you’ve been using TK too long.

A couple weeks ago, I decided that one of my little projects at work needed a better UI then print statements could reasonably provide; I was generating a huge amount of log-like data, and it was getting hard to pick important lines out of the chaff. I started by throwing a curses wrapper around the ruby script that does the actual work, and then separating the logs into three panes on the screen. It worked, but it was impossible to scroll back when things went off the screen, and curses isn’t exactly noted for its ease of use.

So, I tried TK. Again. I keep dragging it out every couple years and hoping that somehow, this years incarnation in this year’s scripting language doesn’t suck as bad as it did last time. I think I can officially say now that TK sucks no matter when or where you try to use it. I write more detail later, but a specific source of suckage in ruby is the near-total lack of english-language documentation. Most suggestions say “look at the perl docs, it’s mostly like that.” The Ruby TK bindings do weird things with threads, and my poor little app kept coredumping. I wanted to do a couple non-standard things with text windows, and I couldn’t find docs on anything even slightly related online. So, once again, I dumped TK.

The current hot GUI toolkit for ruby is Fox, but the current version isn’t in Debian, so I decided to give Ruby’s GTK bindings a try. Of course, it wasn’t available for Ruby 1.8 in sid either, but at least GTK itself was, and (amazingly enough), it was trivial to build. And it worked. I was stunned.

Here’s an example–suppose you want to build a text box with horizontal and vertical scroll bars. In TK it’s easy–just create a text field, then a horizontal scroll bar, and then a vertical scroll bar, then tie them together, then put them into a grid layout thingy and tweak it so that it doesn’t try to shove one scrollbar or the other into the bottom corner. Piece of cake, if you don’t mind typing 10 lines of code and remembering how the grid layout engine works. Got GTK in Ruby, it looks more like this:

    win=Gtk::TextView.new
    scroll=Gtk::ScrolledWindow.new
    scroll.add(win)

That’s it; from here on, you can deal with ‘scroll’ when it comes to layout; it encapsulates ‘win’ so that you never need to worry about it again. Gtk::ScrolledWindow automatically attaches the scrollbars to whatever you shove inside it. If you only want horizontal or vertical scrollbars, there are simple method calls for that. All in all, it just works. If you want to use ‘win’ for displaying text, but don’t want the user to enter text, then call ‘win.editable=false’. Line wrapping, margins, and pretty much everything else is similar. Callbacks largely work as you’d expect in ruby, via anonymous code blocks and yield.

Plus, best of all, there’s documentation. It’s not perfect, or even 100% complete, but it was good enough for me to be able to churn out a non-trival application (dynamically-created tabs, multiple frames, multhreading, collapsing tree widgets, etc) in about a day and a half. Since I’m not really a GUI person, that seems entirely reasonable.

This is the fourth GUI toolkit that I’ve used enough to churn out a small application. I started with Windows somewhere around the time of 2.1 or so (back when Excel came with a free copy of Windows :-), before MSFC or .NET or whatever they’re using these days. ‘Hello World’ was around 30 lines of code. Enough said. After that, I used Motif a bit. It was better, but still painful, and it ate a horrific amount of memory for 1994 or so. I used TCL/TK briefly in 1996 or so; it was a lot easier to code in, but TK is so limited, and it’s difficult to get it to do things that it doesn’t want to do. GTK seems a lot better; it’s clearly a full-sized GUI toolkit, but it’s easy to write small stuff in it. It’s flexible enough–one thing I needed for this ap was “sticky” text windows, where they’d auto-scroll to the bottom when I inserted new text if they were at the bottom before I inserted anything. That took about 5 lines of code, most of which is if/then logic. It only actually took two GTK calls to figure out if I was at the bottom, and 1 call to move the scrollbar.

I may have finally found a GUI I can live with. Amazing. It only took 15 years.

It’s been an interesting week for work, and it’s only Tuesday. We’ve just started a big project at work to replace our existing grammar for Cisco IOS with a new, shiny one that’s more complete, and the sheer size of IOS keeps getting to me. There are probably somewhere around 15,000 IOS configuration commands, as we count them, and the grammar that covers all of them stretches the limits of most parser generators. We’ve been killing yacc this week, it’s been fun.

Once a sysadmin, always a sysadmin. I’m not really sure why (although I suspect the folks on alt.sysadmin.recovery would call it a character defect), but even though I’m mostly a programmer this year, visions of well-managed servers are still dancing through my head. Maybe they’ll stop someday.

Anyway, I’ve been stewing over some interesting ideas on server management recently, and I think we’ve been doing it all wrong. We’ve been trying to build strong, resilient, flexible servers that we can maintain for years, adding and removing services as needed. This is an outgrowth of the way programmers are trained to think, with maintainability prized as once of the highest virtues of software. The XP people have a slightly different take on things, but underneath it all they still prize maintainable systems. On c2.com’s wiki, the discussion of Christoper Alexander’s A Pattern Language is informative, as it shows parallels between software design and building design, concentrating on features in buildings that give them a long, useful life.

I’m not sure that we really want any of that for servers, though, or at least not for standard, cookie-cutter services like DNS. We should be aiming for disposable servers, where the only things that we care about are the configuration state, data, performance, and security. The actual system files, and even OS should be irrelevant, and even ignored if possible.

I’m working on a demonstration, along with a design for a larger-scale system that have some bizarrely nice properties. I don’t see why it wouldn’t work, frankly, and it’ll make a huge change in the amount of work needed to implement small services in networks.

It seems like we don’t get out to see many movies these days, with the kids and all. We finally made it to see Pirates of the Caribbean last week. I enjoyed it, but I’m glad I didn’t fight the rush when it first came out. I need to re-watch Bend it Like Beckham, but I think I liked Keira Knightly better there then in Pirates. On the other hand, Keith Richards, er Johnny Depp’s pirate character was great.

The movie seemed to drag on longer then it really should have, but it was still fun. I figure I’ll end up buying the DVD when it shows up at Costco.

Rant time. I’m pissed off with Linux on the Desktop.

I’ve been using Linux for a long time–since 0.97.1, in August of 1992. I re-wrote chunks of the X server to get it to work better with my video card. I wrote drivers for cheesy video cameras, fixed broken system calls, and so forth. I know Linux. I’ve been running Linux servers professionally since 1995 or so. At Internap, I ran over 700 Linux boxes, including a ton of desktops. My primary desktop system was a Linux box from 1993 until I bought a PowerBook in 2002; I’ve probably only had a Windows box running at home for a month or so since 1993.

I’ve been around Apple systems since 1983 or so–I had an Apple //e, and I lusted after their hardware for years, but I ended up buying a faster PC for way less money in 1988, and I didn’t look back until early 2000. My wife was complaining that it was hard for her to use my Linux box, because it was perpetually just slightly broken. Things like incomplete kernel upgrades, broken X servers, and flaky copies of netscape kept her away from her email. I spent all day keeping the computers at work running; I didn’t want to spend the rest of my time fixing computers at home. Plus, we’d just had our first child, and Gabe was suffering from a lack of tacky home video footage. So, Gabe and I decided to go out and kill two birds with one stone, so we bought a graphite-colored iMac DV and a DV camcorder. I added a wireless networking base station and card for the mac, and it was able to work pretty much anywhere in the house. My wife could read her mail and surf the web, and I could leave broken Linux boxes sitting in the computer room. Everyone was happy.

Sort of. The problem was that the Mac ran OS 9. No matter what Apple people claim, OS 9’s core is about on par with Windows for Workgroups, around 1993 or so. It’s awful. It’s not a modern OS by any metric, with no memory protection, no real multitasking, weird networking, and (of course) no command prompt. It tended to crash a couple times per week, plus I hated using it, just on general principles. But, it was never really broken, because I never wanted to tweak anything on it.

In late 2001, Cyn was griping about an irritating crash of something or other, and was wishing for Emacs and ssh while we were out driving, and I remembered that OS X 10.1 was shipping, and was supposed to be usable. So, we dropped by CompUSA and grabbed a copy, and it was nice. I liked it, because it was a real OS (it ships with openssh, that’s usually real enough for me). She liked it because little crashes didn’t take down the whole system. A few months later, I decided that I needed a laptop and bought a PowerBook G4. I wanted a machine that would let me (a) work (which means mostly SSH, X, and a web browser) (b) run Photoshop and (c) watch DVDs while traveling. On a PC, I’d have had to dual-boot to do (b) and (c), while the Mac could do all 3 at the same time without problems. So, since I’d spent over $2,000 on the laptop, I decided that I was actually going to use it, not just let it gather dust, and started turning off my Linux desktops at home and at work.

And, bizarrely, I was happy. I’ve avoided treating the Mac like a Unix box. I’ve limited the amount of Unix cruft that I’ve drizzled through the filesystem, although I have X and XEmacs installed. I do 90% of my file management through the shell, and I use rsync and scp all the time–I’ve not glued to the GUI, but I enjoy the working environment. Plus, tons of stuff just works, without we needing to spend hours fiddling with it. The system address book syncs correctly with my cell phone. My calendar on the phone syncs with the computer, which syncs with my wife’s at home. Some things, like iTunes, are amazingly right, while others are still a bit flaky, but all in all it’s the most usable Unix I’ve ever seen.

Which brings me, in a round-about manner, to the point that I was starting with. Under the hood, Linux is quite a bit more capable then OS X. It’s faster and cheaper, and it runs on nearly every hardware platform known to man. It’s wonderfully flexible for servers. On the desktop, though, it’s just too flexible. I build my first Linux desktop box in over a year this weekend, with Debian and KDE 3.1. After fighting the usual fight with Debian’s installer, I was able to get X and KDE working after a couple hours (missing drivers, broken dependancies in sid, nothing that I can’t handle, and most of that was Debian-related, not really anything endemic to Linux itself). However, when I was done, I was still left with a hodge-podge of mostly interoperable programs that all worked just a little differently. KDE’s web browser and Mozilla have a hard time printing to the same printer. KDE apps seem to understand the multimedia keys on the keyboard, but Mozilla doesn’t. Sub-pixel antialiasing is set up wrong, and leaves a colored fringe on letters on the cheap LCD that we’re using. There’s nothing like iTunes, which is wonderfully simple to use, yet still manages to just work. Instead, I can accomplish the same basic things, but it takes 2-3 times as much work. But, in exchange for this, I can do it in 15 different ways.

That’s not really a step in the right direction.

On Friday night, we went out for Chinese food, and I watched the waitress add up our bill on paper with a calculator. I started to wonder why they didn’t use a computer–there are tons of opportunities that a computer could help with, besides just adding the numbers right. One local burger drive-in takes orders on iPaqs with wireless cards, and beams the orders back to the kitchen, shaving a minute or two off of each order. So why doesn’t the Chinese place do this? Because it’s freakishly complex and expensive. What are the odds that their computer would work perfectly without failing all year? What happens when (not if) it dies? Can they fix it in-house, or do they need to wait for a consultant to show up? What do they do when it’s down?

After a couple minutes, it seems obvious that paper and calculators is a better approach for this place, and quite possibly most non-chain restaurants, because they can’t afford the incredible cost of keeping their computers working.

I’m not saying that buying computers from Apple would make their lives easier (although it probably would, a little), I’m saying that pretty much everything computer-related right now is too complex and too prone to breaking. And, once it breaks, it takes an expert to un-break it. Computers tend to be brittle and easily broken, and once they break, they can’t fix themselves. There’s no single fix to that, but I’ve seen a few things that help.

1. Don’t be too flexible. Understand the problem that you’re working on, find a good model, and then stick to it. My two favorite pieces of software right now, iTunes and the TiVo both succeed by making it easy to do what you want to do without providing excessive flexibility. Compare to KDE on Linux–how many ways to burn a CD do we really need?

2. Software breaks, computers break, but there’s no reason for them to remain broken. Look at TiVo, or at Internap’s reference system–in either case, the system software for each box is at least partially self-repairing. At Internap, you could overwrite system files and libraries, and odds were it would be repaired and returned to service without anyone ever knowing. Even if the box died completely, we could build a new one and restore the old data exactly within minutes. Appliances like TiVo need to behave the same way–they need to keep low-level problems from turning into high-level problems that the user can see.

3. Virtualize and separate. Something else that we did at Internap that helped was to separate different services onto different physical servers. That’s pretty common at companies that care about reliability; if one server dies, it only takes out one service. You then deploy redundant servers for each service, and things tend to keep working through hardware faults. Software faults still kill you, though. In my ideal world, software would take that even further; I’d love to manage a system made out of smalltalk-like images, where each logical service was entirely contained within a system image that couple be copied around over the network, without any external dependancies. Assembling a network’s worth of services would then become an exercise in bolting together components, and the development side of administration would be mostly creating components.

I need to practice short, coherent rants.

Well, Fry’s Electronics finally opened a store in the Seattle area. Bizarrely enough, I had a easier time finding unusual computer stuff in Bellingham then I’ve had in Seattle. A lot of that is me not knowing where to look, but Seattle seems to suffer from too many CompUSAs and assorted office supply stores, and not enough actual techie-oriented computer stores. Example: I wanted to find a PCI Ethernet card that was supported by a specific kernel build that we were shipping as part of our product at work, and I ended up having to raid my closet at home, because no place in town seems to sell anything other then $20 tulip clones. I don’t know, Intel and 3com have stopped making real Ethernet cards or something, but it’s kind of irritating when you’re only a few miles down the road from The Evil Empire, and you have to mail-order Ethernet cards.

Anyway, Fry’s is here. It’s in Renton, which isn’t my ideal location for an electronics store, but it’s better then Portland, which was the closest Fry’s.

Cyn and I drove down on Saturday. That may have been a mistake, because it looked like everyone else in the entire state was there as well. They had 66 registers open, and the backup from the checkout lines was screwing up foot traffic in about half of the store when we got there.

All in all, it’s not exactly God’s Gift to Geeks, but they did have a lot of stuff in stock, including around 20 different motherboards (including 2 ITX boards), spools of Cat 5 (didn’t look for 5e or 6), multimode fiber with at least a few different connectors (but no singlemode), CPUs (including a couple speed grades of Opteron, although I didn’t see any motherboards), and so forth. Their drive prices weren’t great, but I was able to get a DVD/CD-RW combo drive for $49, which is about $50 cheaper then CompUSA. Not like that’s hard or anything–last time I was there, they wanted $30 for IDE cables ($2.99 from Fry’s, probably $0.17 in lots of 1,000 online).

In the end, I suckered in and spent too much money. My wife has been wanting a new computer for a while, and talked me into getting her a small-form-factor IWill XP-4. With a 2.4GHz Celeron, 512MB of RAM, 80GB drive, wireless keyboard and mouse, plus a 15” LCD, it came to just over $600, which doesn’t seem too shabby. I added a DVD reader and a wireless card that I had sitting around, and we now have a computer in the kitchen, running Linux. I’ll get to that rant later.

Okay, I’ve decided that I like the Shure earphones that arrived on Monday. They’re kind of slow to put on and take off, and it’s hard to interact with people in my office with them in, but that’s not necessarily a bad thing :-). On the other hand, once I switched from the rubbery earpieces for it to the foamy earpieces, it’s a lot more comfortable and it sounds better. It’s still not quite up to the sound quality of my Grado SR-60 headphones, but they’re still pretty good, and the extra noise blocking means that they’re a lot more comfortable to use. Plus, I used the Shures for ~6 hours yesterday (in <2 hour chunks), and I didn’t feel beat up at the end of the day; the Grados might sound a bit better, but the earpieces are kind of uncomfortable and the utter lack of sound shielding on them means that I have to turn them up to get over the background noise in my office. The combination of loud and uncomfortable gets tiring after a while.

Strangely, the Shures seem to sound better with the iPod then the Echo Indigo. I need to do more testing (laptop/ipod, shure/grado), but all in all, I’m pretty happy with the iPod/Shure setup.

I suckered in and bought a refurbed iPod from store.apple.com yesterday. I was weak, and I was getting tired of not being able to listen to music away from my laptop. That, and it was $70 off.

Say what you will about Apple, they know how to package products. This is our second iPod (I got my wife the original 5 GB model shortly after they were released), and I was deeply impressed with the packaging and Apple’s general attention to detail two years ago. The new model is even more refined the the original. The new dock is perfectly weighted, the package itself is a work of art, the remote is cool looking. Heck, even the hold switch on the new iPod looks perfect.

They’re expensive, but somehow it all seems worth it once it’s in your hand. It doesn’t feel cheap like so many products do these days. Frankly, that’s one of the reasons that Apple is still around after all of these years. More then any other computer company, they care about little details, and it shows.

Now if they could only make Safari faster and keep it from crashing once or twice per week.

This morning I received word that Internap, my former employer, will probably be open-sourcing the software that I spent most of my time maintaining while I was there. This is a Good Thing.

The Reference System was the software system that we used to manage the configuration of roughly 700 servers spread across the US, plus Tokyo, London, and Amsterdam. It took about 1/2 of a staff member to maintain the software on all 700 systems, including upgrades, security fixes, and so on. We could literally clone or reconstruct any server in the company within minutes, plus the time needed to restore data (but not software) from tape.

I’ve had a ridiculous number of former co-workers ask me for a copy of the source to the reference system. Once you get used to it, you don’t want to manage piles of servers without it.

I’ve posted a few sets of pictures at http://scottstuff.net/gallery. Right now, there aren’t a lot of pictures there, and they aren’t my best by any stretch, but at least they’re available. I’ll try to add more as time goes on. Of course, I’ve tried to do that for years, and never really found a workflow that works right for me. I’ve went for quick-and-easy this time instead of complex-and-flexible; maybe I’ll be able to stick with it for once.

I’ve had at least one complaint that there’s something wrong with the gallery when viewed in IE on XP, but I know that it’s worked for other people. Sigh. I love Windows.

A few months ago, I came to the conclusion that I’d never get any work done when constantly dealing with all of the little distractions that come from working in a shared office space. I miss my private office. Oh, well. Anyway, I bit the bullet and bought a set of Grado SR-60 headphones. They sounded nice when I was trying them out, but I wasn’t all that impressed with them when I plugged them into my PowerBook.

First, most headphones claim need a few hours or even days of use to “break in.” After a day or so, the Grados did sound a bit better, but there’s no real way to quantify or repeat that, so it might just be Audio Lore. Second, I discovered that the Grados sound better if I shift them up and back a bit on my ears from the Position of Maximum Comfort. They sound better then, but they’re less comfortable. They still didn’t sound all that hot with the laptop, though, and I was starting to regret buying them. Interestingly enough, they sounded better with my wife’s iPod. So, apparently my PowerBook has a cheap headphone amp. Apparently that’s normal; most consumer electronics equipment comes with cheap headphone amps.

Fortunately, the electronics industry is just great at building new things to sell to work around problems like this, and $99 later I was the proud owner of an Echo Indigo PCMCIA (CardBus actually) soundcard for my laptop. The Indigo is sort of an interesting beast; it’s a soundcard designed for headphones. It has a pair of 1/8” headphone jacks on it and an analog volume dial. It has drivers for most recent versions of Windows as well as OS X; unfortunately the Mac drivers would crash your box if you ejected the card until a month or two ago. Grrrr. It works perfectly now, though.

Sound quality-wise, though, the Indigo has been perfect from day one. It’s clearly better then the built-in headphone jack. Everything sounds way clearer. Music is more enjoyable. The Grado/Indigo combo sounds way better then any home stereo I’ve owned.

The only real problem is comfort–the Grados get uncomfortable after a couple hours of listening. They’re a bit scratchy, and they start to feel oppressive after a while. Plus, they don’t block any of the ambient noise in your environment, so the only way to block noise is to turn the volume up louder. I like loud, but then everyone else in the office gets to share, and I get a headache after an hour or two.

I should probably mention that my office is especially loud right now–I have a pile of Cisco gear 5-10 feet from my desk, including a 7505, two 7204s, a Cat 6505, and a couple PCs with industrial-grade cooling fans. It’s loud. It’s hard to conduct conversations at normal volumes.

So, I just bought a set of Shure (yeah, the microphone people) E2c earphones. They go in the ear, not on it. Think “earplugs with speakers in them” and you’re won’t be far from the truth. The jury’s still out on the Shures; they’re reasonably comfortable, and they block lots of noise, but they don’t sound nearly as sweet as the Grados.