When I first started reading blogs, blogrolls made intuitive sense tome. You had to keep track of the URLs of the blogs you read somehow, andmaking your reading list public was the friendly thing to do. This viewwas so clear to me that at one point I considered writing a techblogentry about how I didn't have a blogroll because I used differentmethods to keep track of my various blog reading.

(Possibly I would have talked about how the rise of feed readers wouldaffect blogrolls. There

Suppose that you have code that generates an abstract 'list' of somesort and returns it inside a try:/finally: block. There are two commonways to code this; you can return a real list, or you can use yield tobe a generator. You might even code it one way and change it to the otherlater, which is generally a transparent change.

Not this time, though. If you are using finally: , the two options canhave quite different behavior. Constructing an example

There are at least two ways to set up vacation messages; they cango to the envelope sender (the SMTP MAIL FROM ), or they can go tothe apparent author of the mail message, usually plucked from the From: header. It's my personal view that mailing list managers shouldimmediately unsubscribe people who have the second sort of vacationmessage system.

(I admit that I haven't always had the courage to do this for liststhat I run.)

It's one thing to harass

One of the reasons that alerting is a tough problem to solve well iswhat I'll call the dependency problem. It goes like this: imagine thatyou have a nice monitoring system and it's keeping track of all sortsof things in your environment. One day you get a huge string of alerts,reporting that server after server is down. Oh, and also a networkswitch isn't responding.

Of course, the real problem is that the switch has died. It's beingcamouflaged behind

Suppose that you have a Solaris fileserver and a bunch of NFS clients(in this case they're Linux machines, but I don't think it matters).Perhaps one or two of them are Samba servers. Further suppose that yourclient machines start reporting things like ' fcntl() failed: No locksavailable '. What is limiting you, and what do you do about it?

(We'll assume that you use tools like lslk to rule out some process ona client machine holding on to

It's worth saying this explicitly: monitoring systems have two differentpurposes, one of which is sort of a subset of the other (but notnecessarily).

The first purpose of monitoring, and what many people initially installa system for, is alerting, letting you when there are problems. Thesecond purpose of monitoring is tracking, gathering ongoing data forhistorical analysis; this is part of the vital work of gettingstatistics . Put this way, it's clear that these twooverlap (sometimes badly )

Here is something important to remember when designing systems andinterfaces: users are lazy . Worse, not only are users lazy butthey're very good at detecting pointless work.

What is pointless work? Simple: it's work that the user doesn't see anyvisible benefit from performing (or doesn't understand the benefit andso discounts it, or feels that the benefit is a lot smaller than you'remaking it out to be). Of course, the work is not pointless to you

A long time ago, I wrote some stuff on how generators are not lists (okay, technically it was about iterators), andone of the things that I mentioned is that generators do not havelist methods. Well, there's a consequence of that that only struck merecently: you need completely different code to modify a returnedgenerator than to modify a returned list .

Suppose you have a function that returns something that is conceptuallya list of items. Further suppose that you have another function thatmodifies what

There is a fashion in monitoring systems that, once you have one, youstart monitoring and alerting on everything that you possibly can thinkof, no matter what it is. If you can measure it, you do, and when itgets too big or too small your system lets people know about it.

This is, by and large, a mistake.

It is a mistake because you've created a system that isn't actually(usefully) informative, just noisy. What your monitoring system shouldbe