Taak 2: Eén functie, één verantwoordelijkheid

Functies die meerdere dingen tegelijk doen zijn lastig om te testen en aan te passen. Een goede helper-functie doet precies één ding: één berekening, één actie, of één controle.

Voorbeeld: alles door elkaar

def process_data(records):
    valid = []
    for r in records:
        # validatie
        if r["age"] > 0:
            # transformatie
            r["age_group"] = "volwassen" if r["age"] > 18 else "jong"
            # logging
            print(f"OK: {r['name']}")
            valid.append(r)
    return valid

Problemen

• Lastig testen: wil je de validatie testen? Heel script moet draaien en printen.
• Lastig wijzigen: verander de output-regel, en je breekt misschien de logica.
• Lastig herbruiken: je kan de validatie niet in een ander script gebruiken.

Oplossing: split in helpers

def is_valid_age(age):
    return age > 0

def get_age_group(age):
    return "volwassen" if age > 18 else "jong"

def log_valid_record(name):
    print(f"OK: {name}")

def process_data(records):
    valid = []
    for r in records:
        if is_valid_age(r["age"]):
            r["age_group"] = get_age_group(r["age"])
            log_valid_record(r["name"])
            valid.append(r)
    return valid

Interactieve demo

Het concept van "één functie, één verantwoordelijkheid" heet in de beroepspraktijk Single Responsibility Principle (SRP). Het is een van de meest krachtige designregels in softwareontwikkeling.

Waarom is dit belangrijk?

Wanneer elke functie één ding doet:

• Testen wordt simpel: is_valid_age(18) testen vereist geen heel script.
• Wijzigen is veilig: get_age_group() aanpassen raakt andere functies niet.
• Herbruiken is makkelijk: is_valid_age() kan in elk ander script gebruiken.
• Lezen is duidelijk: je begrijpt direct wat log_valid_record() doet.
• Debuggen is snel: bug in validatie? Kijk alleen in is_valid_age().

Naamconventie — de naam zegt wat het doet

Kies namen die de verantwoordelijkheid uitdrukken:

• Getters/calculators: get_ of calc_ — geven iets terug
  • get_age_group(), calc_total_cost()
• Validators: is_ of validate_ — checken iets en geven True/False
  • is_valid_age(), validate_email()
• Acties: werkwoord (bv. save_, send_, log_)
  • log_valid_record(), save_photo()

Veelgemaakte fouten

Fout 1: Te veel in één functie

# ❌ FOUT: één functie doet alles
def register_user(user, users):
    # controleren
    if "@" not in user["email"]:
        return False
    # opmaken
    user["name"] = user["name"].title()
    # opslaan
    users.append(user)
    # melden
    print("Gebruiker opgeslagen")
    return True

# ✅ JUIST: elke functie één taak
def is_valid_email(email):
    return "@" in email

def format_name(name):
    return name.title()

def save_user(user, users):
    users.append(user)

def log_saved_user(name):
    print(f"Gebruiker {name} opgeslagen")

Fout 2: Side effects verstopt

# ❌ FOUT: functie doet twee dingen tegelijk
def calculate_age(birth_year):
    age = 2024 - birth_year
    print(f"Leeftijd: {age}")  # Verstopt side effect!
    return age

# ✅ JUIST: scheiding van concerns
def calculate_age(birth_year):
    return 2024 - birth_year

# Aparte functie voor output
def display_age(age):
    print(f"Leeftijd: {age}")

# In het hoofdscript:
age = calculate_age(1990)
display_age(age)

Parameters optioneel maken — beide varianten

Soms is het handig om functies flexibel te maken met default parameters:

# Variant 1: Altijd expliciete parameter
def log_record(name, level):
    print(f"[{level}] {name}")

log_record("Alice", "INFO")
log_record("Bob", "ERROR")

# Variant 2: Met default parameter
def log_record(name, level="INFO"):
    print(f"[{level}] {name}")

log_record("Alice")           # Gebruikt "INFO"
log_record("Bob", "ERROR")    # Override naar "ERROR"

Interactieve demo

Scenario: de drone krijgt een vluchtplan als lijst van stappen. Niet elke stap is bruikbaar: er staat een richting in die niet bestaat, en een stap die binnen te ver gaat. Jouw script vliegt de goede stappen en slaat de foute over — met een melding waarom. Dat bouw je niet als één grote lus vol if's, maar met kleine helpers die elk één ding doen.

Gegeven:

VALID_DIRECTIONS = ["forward", "back", "left", "right", "up", "down"]
MIN_DISTANCE = 20     # cm, kleiner kan de drone niet
MAX_DISTANCE = 200    # cm, binnen niet verder per stap

flight_plan = [
    {"direction": "forward", "distance": 100},
    {"direction": "left", "distance": 50},
    {"direction": "sideways", "distance": 50},
    {"direction": "back", "distance": 100},
    {"direction": "right", "distance": 250},
    {"direction": "right", "distance": 50},
]

Je taak: schrijf minstens vier helpers: één die een stap controleert, één die bij een richting de juiste drone-beweging opzoekt, één die een stap vliegt, en één die een logregel maakt. Het hoofdscript gebruikt ze om het plan te vliegen.

Acceptatiecriteria:

• Elke helper doet één ding, en zijn naam zegt wat (controleren, opzoeken, vliegen, opmaken)
• De controle-helper geeft terug óf een stap mag én waarom niet — en gebruikt daarvoor geen drone
• De beweging wordt opgezocht in een dictionary met drone-methodes, niet met een if/elif-keten over richtingen
• Met de drone: de vier geldige stappen worden gevlogen, de twee foute overgeslagen met een melding met waarde en grens
• De drone landt altijd, ook als een commando halverwege een fout geeft

Scenario: na elke gevlogen stap wil je een foto, zodat je achteraf ziet waar de drone was. Ook hiervoor schrijf je helpers volgens hetzelfde patroon.

Hints:

• Eén helper haalt het huidige beeld op, één maakt de bestandsnaam, één slaat het beeld op
• De helper die de bestandsnaam maakt, heeft geen drone nodig — die kun je los testen
• Denk aan namen die met een werkwoord beginnen: get_, make_, save_
• Overgeslagen stappen krijgen geen foto; bedenk hoe het nummer in de naam dan blijft kloppen

Acceptatiecriteria:

• Na elke gevlogen stap staat er een foto met het stapnummer in de naam, bijvoorbeeld step_04.png
• Minstens drie foto-helpers, die elk één ding doen
• De naam-helper is zonder drone getest met minstens twee stapnummers