Repetition II — Functions

Why This Matters

Last chapter you learned to make the computer do the same thing many times. This chapter you learn to make the programmer — that's you — write the same thing only once.

The cost of repeating yourself in code is enormous and quiet. When you write the same logic in three places and a bug shows up in one of them, the bug is also lurking in the other two. The fix is functions — a chunk of code with a name, written once, used anywhere.

The Christian intellectual tradition has worked the same way for centuries. Aquinas didn't reinvent the Cosmological Argument every time. Pascal didn't write the wager fresh in each Pensée. Once an argument is carefully built, reusing it is a virtue, not laziness.

The Anatomy of a Function

double bayes_update(double prior, double L_H, double L_notH) {
    double num = L_H * prior;
    double den = num + L_notH * (1.0 - prior);
    return num / den;
}

• double — what the function returns.
• bayes_update — the function's name. Verb phrases for functions; nouns for variables.
• (double prior, double L_H, double L_notH) — parameters. These are local variables that exist only inside the function.
• return num / den; — sends a value back to whoever called the function.

Pass by Value vs. Pass by Reference

By default, function parameters are copies of what you passed in. Modifying them inside the function doesn't affect the caller:

void try_to_double(int x) {
    x = x * 2;     // modifies local copy only
}
int n = 5;
try_to_double(n);
cout << n;   // still 5, not 10

To let a function modify the caller's variable, mark the parameter with &:

void actually_double(int& x) {
    x = x * 2;     // modifies the caller's variable
}

Use pass-by-reference when you want the function to modify state in the caller, or for large objects where copying would be expensive. Use pass-by-value (the default) almost everywhere else.

Composition

Functions can call other functions. This is where the power compounds:

double chained_bayes(double prior,
                     double L1_H, double L1_notH,
                     double L2_H, double L2_notH) {
    double first  = bayes_update(prior, L1_H, L1_notH);
    return bayes_update(first, L2_H, L2_notH);
}

chained_bayes applies Bayes twice — once with the first piece of evidence, once with the second. The actual math lives in bayes_update, in one place. The bigger function just composes the smaller one. This is the move that distinguishes working programmers from beginners.

Coach's Note — Beginners write one giant function that does everything. Working programmers write twenty small functions, each doing one thing, that combine. The latter is easier to read, easier to debug, easier to change.

This Week's Project

You're ready for Project 5: Reasoning Toolkit. A menu-driven program with five named operations — Bayesian update, modus ponens, complement, conjunction, validity — each its own function. main is just the menu loop and dispatcher.

void doubleIt(int x) {
    x = x * 2;
}

int main() {
    int n = 5;
    doubleIt(n);
    cout << n;
    return 0;
}

← WEEK 4: LOOPS   ·   WEEK 6: COLLECTIONS →