Here's a question that interests me: why don't I havea standard C version of my Python warn() function ? The Python version shows up in mostprograms I write, but in my C programs I generally directly fprintf() errors to stderr, instead of having a utility function for it.

Part of the reason is that a C version of warn() really calls for adifferent and more complicated set of arguments. Instead of a singlestring, the natural C-ish approach is

Here's some things on printing standard format Unix errors in Python programs specifically,based on things that I've both seen and done myself.

First, I tend to wind up putting standard warn() and die() functions into my programs, but they only handle very low level details(putting the program name in and flushing things as necessary ). Beyond that:

• you should always catch EnvironmentError instead of anything morespecific. Functions are inconsistent about whether they raise IOError or OSError , so you shouldn'

So one recent tidbit of news from Slashdot is that people are shocked, utterly shocked that some bad people are using EC2 to host machines thatdo bad stuff and that Amazon is surprisingly ineffective about stoppingthis.

Well, yes. Hello, here is a newsflash: cheap or free hosting (it's freeif you use other people's credit card numbers) attracts bad people likeflies to honey, and people operating cheap services rarely (by whichI mean 'never') staff up their abuse department

I've noticed a pattern lately: I have a number of infrequently rebootedmachines, and every time I reboot one of those machines I wind upsitting and drumming my fingers as the machine cheerfully announces'filesystem X hasn't been checked in N days, checking for you'. It takesa while, because these filesystems are often kind of big and kind offull of things.

This is not ext3's fault; it is faithfully doing what it is configuredto do, and even with all

Every so often I run into someone who has drunk the XHTML koolaid. Fora long time I didn't really know what to say to them about it; whileI have strong opinions about this, my usual discussion of this isfairly long and somewhat tedious, and thus not quite the thing to dropinto conversation to convince people. What I needed was not a longreasoned argument against XHTML (complete with a careful inventory of its practical problems ) and in favour of, say, HTML 4.01

Suppose that you're writing a command like, say, make ; it writesprogress output to standard output and error reports to standard error,and it doesn't necessarily immediately terminate when it encounters anerror (or prints a warning; the important thing is that it keeps runningafter it prints things to standard error).

There's a subtle catch in how you want to print things (such as standard error messages ) to stderrin such a program. You don't want to just do the

As a sysadmin, I have developed strong and quite fixed opinions abouthow Unix programs should format their error messages for maximum usefulreadability by harried sysadmins. Today I feel like boiling it down towhat I will grandly call the standard format Unix error message, whichis the format you should use unless you have a really good reason to dootherwise.

The standard format message should be written to standard error, andlooks like:

program: general problem: specific error message

A typical example would be:

mycat: cannot open

There is a quietly pervasive myth in multi-sysadmin groups that therecan be an environment without specialists, where every sysadmin can doevery job that the group does equally well. If you do much work of anycomplexity, this idea is not just false but crazy.

I call it crazy because of what it requires. In general, it invariablytakes a significant amount of research, learning, and experimentation tobecome a (semi-)expert in a technical area such as Exim configuration,OpenBSD firewalls, ZFS,

We had a performance problem today that we fairly rapidly determinedcame from our mail spool filesystem somehow being too slow. This waspretty impressive, because our mail spool sits on a four-way mirror on our fileservers and we could easilysee that our IO rate on its fileserver wasn't particularly large, wellbelow what we knew things could manage.

(Using NFS with a single interface makes IO rate easy to measuredirectly, no matter how complex your IO system; just look at the networktraffic volume.)