The nice thing about this approach is that debugging can be turned on or off easily at compile time. However, my experience has been that it leads to a lot of typing, and seeing too many macros in the middle of code makes my brain explode in a fiery rage. So, I figured that if I wrapped my prints in another function (I called mine ‘log’ and ‘error’), I could avoid this whole mess and keep my sanity. I’ve done this with a number of other projects in other languages, but I had to learn some magic to do it in C.

Lesson Learned #1 : Variable arguments. It turns out you can define functions that take a variable number of arguments with va_list (from ). You define such a function:

void log(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
...
va_end(args);
}


Lesson Learned #2 : However, from what I can gather, you can’t just inject printf directly into this. However, having anticipated this, there is a set of functions designed for cases like this: vfprintf, vprintf, vsnprintf, vsprintf. The ‘v’ stands for va_list (variable-argument list), and you can use them just like you’d expect:

void log(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
fprintf(log_fd, "NOTE : ");
vfprintf(log_fd, fmt, args);
va_end(args);
}


The thing I like about this approach is that you have control over how log messages get printed in one place. So, for example, if I provided another function, setLogFD, then I could easily just set the file descriptor where all log messages get printed. So easy! Something I’ve used this for in other instances (especially servers) is to also inject additional information like a timestamp on every message. So, when I call:

log("Some event '%s' just happened.\n", event_name);


Then I automatically get “NOTE : ” and maybe a timestamp prefixed on that message. Which make code look clean, and adds a great deal of functionality. I actually added another function error(…) that prints to a different file descriptor in case I want to suppress debug messages, but no error messages. For additional layers of debugging, you might do something like this:

void log(int level, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
FILE* fd = my_log_files[level];
fprintf(fd, "NOTE : ");
vfprintf(fd, fmt, args);
va_end(args);
}


This way, at startup, you could easily set some of the file descriptors in my_log_files to stderr and some to point to /dev/null or otherwise dissolve into the ether.

Scenario: you need to boil some water to incapacitate a guard (a hot cup of tea puts him right to sleep. Also, he’s very trusting when it comes to strangers offering him tea), and you’ve got sandpaper, two soda cans, a razor, a tuft of fiberglass insulation, a tack and a bottle of Heet at your disposal. Also, the internet to watch this metacafe video.

I had seen this before and in various design complexities, but I really like the compactness and ease of this one. I decided to scrounge up some Heet ($2.10 at a local gas station), a couple of cans, sandpaper and a razor blade (both on hand), and pull a little piece of insulation off of some that happened to be sitting in our basement.

It got surprisingly hot – I tried setting an oven rack over it with a kettle (to knock out that tea-loving guard), and it started to melt one of the bars of the rack. I expected it to be hot, but not hot enough to melt parts of an oven rack. Who knew?

Success: certainly.

Made from one of those yellow connectors (if you know the name of what I’m talking about, please let me know), I snapped off the part where you put the wire in and then clamp it with pliers. Before using that, I made sure I had the right setting (I wanted this one as the slave HD), by touching a screwdriver to the two pins associated with that setting and held it there as I booted the machine. Probably a safe/smart move (but in all reality, how much current flows through those pins, anyway?).

I used this Lifehacker article as a guideline. All in all, it took about an hour.