Taak 1: Alles in één bestand

Naarmate scripts groeien, worden ze lastig te hanteren. Alles op één hoop leidt tot problemen.

Monolithisch script — 200+ regels

# payroll.py — alles in één bestand

def load_employees():
    ...    # 20 regels: gegevens klaarzetten

def is_valid_email(email):
    ...    # 15 regels: controles

def calculate_salary(hours, rate):
    ...    # 15 regels: berekeningen

def format_payslip(name, salary):
    ...    # 30 regels: loonstrook opmaken

def send_notification(email, text):
    ...    # 25 regels: bericht versturen

# Hoofdlogica
employees = load_employees()
for employee in employees:
    if is_valid_email(employee["email"]):
        salary = calculate_salary(employee["hours"], employee["rate"])
        payslip = format_payslip(employee["name"], salary)
        send_notification(employee["email"], payslip)

Problemen die optreden

• Moeilijk navigeren: 200 regels doorzoeken voor één functie
• Testen lastig: wil je één functie testen? Hele script moet draaien
• Herbruik moeilijk: moet je validate_email in ander script? Copy-paste...
• Fouten in alles: bug in één plaats raakt potentieel alles

Interactieve demo — bestandsstructuur vergelijken

Modularisatie is de oplossing voor grote projecten. Elke module krijgt één verantwoordelijkheid.

Wat is modularisatie?

Je code opsplitsen in modules (aparte `.py` bestanden), elk met een duidelijk doel:

• validation.py — alle checks (email, password, etc.)
• calculations.py — salarisberekening, statistieken
• reports.py — rapporten opmaken
• notifications.py — emails, alerts
• main.py — de "dirigent" die alles coördineert

Voorbeeld: Gemodulariseerde aanpak

# validation.py
def validate_email(email):
    return "@" in email and "." in email

def validate_password(pwd):
    return len(pwd) >= 8

# calculations.py
def calculate_salary(hours, rate):
    return hours * rate

# main.py
from validation import validate_email, validate_password
from calculations import calculate_salary

user_email = "alice@example.com"
if validate_email(user_email):
    print("Email OK")

Voordelen

• Herbruik: importeer validate_email in elk script dat het nodig heeft
• Testen: test validation.validate_email() apart, zonder rest van project
• Navigatie: weet je wat je zoekt? Ga naar validation.py
• Samenwerken: de één werkt aan validation.py, de ander aan calculations.py, zonder elkaar in de weg te zitten

Veelgemaakte fouten

Fout 1: Te veel in één module

# ❌ FOUT: helpers.py is volgestopt
def validate_email(email):
    # ...

def calculate_salary(hours):
    # ...

def save_to_database(data):
    # ...
# Waar is wat?!

# ✅ JUIST: één verantwoordelijkheid per module

Fout 2: Circulaire imports

# ❌ FOUT: validation.py importeert calculations
# calculations.py importeert validation
# → ImportError!

# ✅ JUIST: eenrichtingsverkeer — main.py importeert alles

Praktische overwegingen

• Wanneer splitsen? 100-150 regels per bestand is een fijne grens
• Naamgeving: zeg wat het doet — email_validator.py i.p.v. util.py
• Noem een module nooit naar een bestaande module: een eigen random.py of io.py schuift de standaardmodule opzij — dat zie je in taak 3

Interactieve demo — bestandsstructuur vergelijken

Scenario: een klasgenoot heeft een script geschreven dat de drone een vierkant laat vliegen. Het werkt, maar constanten, controles, vliegbewegingen en de opstartcode staan door elkaar in één bestand. Jij knipt het op, zodat de controles te gebruiken zijn zonder drone. Daarna vlieg je het vierkant opnieuw, om te bewijzen dat er niets kapot is gegaan.

Gegeven:

# square_flight.py — alles in één bestand
from djitellopy import Tello

MIN_BATTERY = 30
SIDE = 60

def battery_ok(battery):
    return battery >= MIN_BATTERY

def format_status(battery, height):
    return f"Accu: {battery}% (min: {MIN_BATTERY}%) | hoogte: {height} cm"

def fly_square(tello, side):
    for i in range(4):
        tello.move_forward(side)
        tello.rotate_clockwise(90)

tello = Tello()
tello.connect()
battery = tello.get_battery()
print(format_status(battery, tello.get_height()))

if battery_ok(battery):
    tello.takeoff()
    fly_square(tello, SIDE)
    print(format_status(tello.get_battery(), tello.get_height()))
    tello.land()
else:
    print("Niet opgestegen: accu te laag")

Je taak: verdeel dit script over vier bestanden: één voor de constanten, één voor de controles, één voor de vliegbewegingen en een hoofdscript. Bepaal zelf de bestandsnamen en welke functie waar hoort.

Acceptatiecriteria:

• Elk bestand gaat over één onderwerp, en de naam van het bestand zegt welk
• Het bestand met controles kun je importeren en gebruiken terwijl de drone uit staat
• Elke constante staat maar op één plek en wordt geïmporteerd waar hij nodig is
• Het hoofdscript bevat geen def, en importeert alleen wat het echt gebruikt
• Met de drone vliegt het vierkant precies zoals vóór het opknippen, met de status ervoor en erna

Scenario: voor elke vlucht wil je snel kunnen zien of de drone klaar is, zonder dat hij opstijgt. Schrijf een tweede script preflight.py dat verbindt, de status toont en zegt of er gevlogen mag worden. Nu merk je wat opknippen oplevert: je hoeft niets te kopiëren.

Hints:

• Kijk welke functies uit je modules je hier opnieuw kunt gebruiken
• Zet er een temperatuurcontrole bij (grens 60 °C, uit sprint 2) — in het bestand waar controles horen, niet in preflight.py
• Bedenk of square_flight nu óók de temperatuur moet controleren, en wat je daarvoor moet aanpassen

Acceptatiecriteria:

• preflight.py laat de drone niet opstijgen en bevat geen gekopieerde functies
• De uitvoer toont accu en temperatuur, elk met hun grens, en een eindoordeel: klaar of niet klaar
• Beide scripts gebruiken dezelfde controlefuncties uit dezelfde module