torvalds

Good Taste

The linked list example

Linus Torvalds showed two ways to remove a node from a singly linked list.

Without taste (the standard textbook approach):

void remove(list *head, list *target) {
    list *prev = NULL;
    list *cur = head;
    while (cur != target) {
        prev = cur;
        cur = cur->next;
    }
    if (prev)
        prev->next = cur->next;
    else
        head = cur->next;
}

The if (prev) branch exists because the head node has no predecessor. Removing the first element is a special case: instead of patching the previous node's next pointer, you must patch the head pointer itself. Every reader of this function has to understand that the head is different from every other node, and that this branch handles it.

With taste:

void remove(list *head, list *target) {
    list **pp = &head;
    while (*pp != target)
        pp = &(*pp)->next;
    *pp = target->next;
}

The indirect pointer pp always points to the next field that refers to the current node. For the head, pp points to head itself. For every other node, pp points to prev->next. The assignment *pp = target->next patches whichever pointer was referring to the target, whether that was head or some node's next field.

The special case disappeared. Not because we handled it elsewhere, but because we chose a representation where head and non-head are the same. The branch was never necessary. It was an artifact of the data structure choice (prev pointer), not of the problem.

Why the first version is bad code:

1. The branch doubles the mental load. A reviewer must verify both paths are correct and that the condition is right.
2. The branch is easy to get wrong. Off-by-one in the prev == NULL check, or forgetting to update head, are common linked-list bugs.
3. The branch doesn't scale. If you add a tail pointer, you need another special case. The indirect-pointer version handles it with zero additional code.