Let’s reduce the task of writing software to a problem of communication: transferring a message from point A (you) to point B (cpu). The message is the software’s high-level specification (source code). The message is conveyed by the information transmitted from A to B (machine code).

Problems arise when B doesn’t do what A wants because the source code has bugs. We’re all used to this and know how to fix it. After it’s fixed the machine code instructs B to do what we want. But, what else does it do? Is every instruction necessary? I’m not thinking about optimizing instructions for performance, but more about flow control and the logical implications of minimal message passing. For example, consider this function:

int
ComputeAdditiveOperResult(string oper, int a, int b)
{
    if ("add" == oper) {
        return a + b;
    } else if ("subtract" == oper) {
        return a - b;
    } else {
        throw InvalidAdditiveOper();
    }
}

The variable oper is used to select one of two useful branches. The “third” branch is essentially an invalid branch.

It only takes 1 bit to communicate which branch should be taken, but many more bits are present in oper because of its type, string. The oper parameter could have type enum {ADD, SUBTRACT } instead. Again, this isn’t about the tiny performance gain you’d get by comparing one bit instead of many; it’s about avoiding doing things that aren’t necessary.

We can all try to practice this, but I think it would be great if it were enforceable. Consider a programming language that warns you if you don’t use every bit of information you request. The function above could produce something like:

Warning: parameter 'oper' contains many bits of information, but only 1 bit is necessary

Doing it right would be tricky, because if instead of

throw InvalidAdditiveOper();

it was

throw InvalidAdditiveOper(oper);

then every bit of oper would be completely used by ComputeAdditiveOperResult, because using a variable as an argument uses every bit of the variable in the current scope.

Character data and such would be fine as long as it were printed or stored, but variables used for flow control could be given strict requirements. You could probably do this with enums, but it wouldn’t be the same. Realistically, this level of strictness would probably be more annoying than it would be useful, but I think it’s a good example of a new idea that was inspired by an old, abstract idea.

Read old books or don’t read any.

In short, I like making things work. When something breaks, it is fun to fix it. If it breaks again in the exact same way, it is still fun to fix. Learning why the problem occurred is only useful because you can use the experience to solve it again. If you knew for certain that the problem or one releated to it would never occur again, it would not hurt to remove all knowledge of the solution from your memory. It’s useless. Such an isolated problem probably doesn’t exist, especially if you like to generalize problems, but the point stands.

The kind of problems I don’t like are the ones in which the pain of designing and implementing a mitigation overshadows the pleasure of implementing a solution. Even if you like fixing cars, if your car breaks down while you’re driving, you’re pissed. You have to get all those tools out and look at a bunch of stuff and who cares what else — you’re physically stuck somewhere with a heavy, expensive, immobile piece of whatever it is they use to make cars. Or, you have to call some random number and explain a bunch of stuff and spend money and you don’t even get to fix it.

When you’re programming, unless you’re editing live code like only rock star web developers do, you rarely have to work hard to mitigate problems. Sometimes the problem doesn’t even require mitigation and you can skip right to the solution. The narrower the scope of your problem, the less mitigation.

Incompatible iterators? No mitigation. Trying to dereference a null pointer? No mitigation (this code isn’t live, remember). Syntax error? How embarrassing, but there’s no mitigation. The more a language allows you to shoot yourself in the foot, the more opportunities you have to solve problems that don’t require mitigation, the more enjoyable it can be to use the language. C++ allows and encourages you to statically check your balls off, which narrows the scope of your problems, which makes it, for me, a very enjoyable language to use. Get yourself a good IDE to cut down on text editing and compilation time and you can’t ask for much more.

chmod o+r /etc/wordpress/config-nochris.com.php

but when it’s the magic command to get WordPress working and every other approach I thought of failed, I don’t care as much. Besides, I’m the only user on this server. (right?)

Also, hello.