MYP Design Functions and Modular Design Notes

A Function Is One Job With a Name

1. A function is a named block of code that does one job, which you can run from anywhere just by using its name.
2. Defining a function writes the instructions down, and calling it is what makes them actually run.
3. In Python you define with def flash_led(): and call with flash_led(), where the brackets on the second line are what sets it going.
4. Defining a function and never calling it means nothing happens at all, which is one of the quietest bugs a beginner meets.
5. A good function does one thing you could name in three words, like "read the sensor" or "show the score".

Parameters Let One Function Do Many Jobs

1. A parameter is a named slot written inside the brackets of the definition.
2. An argument is the real value you drop into that slot when you call the function.
3. So def flash_led(times): has one parameter, and flash_led(3) passes the argument 3 into it.
4. Parameters are what stop you writing flash_once, flash_twice and flash_three_times as three near identical functions.
5. Order matters, so a function defined as beep(pitch, length) and called as beep(200, 500) sets pitch to 200 and length to 500.
6. Name parameters as carefully as variables, since pause(ms) tells the reader the unit and pause(x) tells them nothing.

Return Values Hand an Answer Back

1. return sends a value back to whatever called the function, and the call gets replaced by that value.
2. If def average(a, b): return (a + b) / 2, then result = average(4, 6) puts 5.0 into result.
3. A function with no return still works fine, which suits anything whose job is to act rather than to answer.
4. return also stops the function on the spot, so any line written after it never runs.
5. Keep functions that answer questions separate from functions that do things, because one that does both is far harder to test.

Scope: Where a Variable Can Be Seen

1. A variable created inside a function is local, and it disappears the moment that function finishes.
2. A variable created outside every function is global, and any function in the program can read it.
3. Local scope is useful rather than annoying, since two functions can each use a counter called i without tripping over each other.
4. Changing a global from inside a Python function needs the word global on a line of its own first, which is usually a hint that a parameter would be tidier.
5. Bugs where a value seems to reset itself are almost always a local variable sharing a name with a global one.

Repeated Code Is a Function Waiting to Happen

1. Copy three lines and paste them elsewhere and you now have two places to fix when the logic turns out wrong.
2. Turn a repeated block into a function the second time you need it, rather than waiting until the fifth.
3. A function also puts a name on the block, which explains the code better than a comment sitting above it.
4. Shorter main code is easier to check against your flowchart, because one call lines up with one box.
5. Having one place to change is what makes a design testable, since you can retune the buzzer once and hear the new tone everywhere.

Building a Program From Modules

1. A module is a group of related functions kept together, such as everything that touches the display.
2. A typical micro:bit project splits into three modules: read the inputs, decide what to do, drive the outputs.
3. The main program then reads as five or six calls in a row, which someone else can follow without reading any of the detail.
4. Modules can be built and tested one at a time, so a broken display module does not stop you proving the sensor module works.
5. Group projects split along module lines, since two people can write two modules once they agree what goes in and what comes out.
6. Agreeing those inputs and outputs before anyone writes code is the step people skip and then spend an afternoon regretting.