Welke beoordelingscriteria voor code in procedurele stijl kunnen als goed en welke als slecht worden beschouwd?

Goede criteria:

• Leesbaarheid: Hoe gemakkelijk is het om te begrijpen wat de code doet door het van boven naar beneden te lezen.
• Duidelijkheid van variabelen en functies: Gebruik van beschrijvende namen die hun doel en logica weerspiegelen.
• Decompositie: Het opdelen van complexe taken in kleinere, beheersbare functies. Elke functie moet een specifiek doel hebben.
• Afwezigheid van globale variabelen: Minimaliseren van het gebruik van globale variabelen om afhankelijkheden en bijwerkingen te verminderen.
• Foutafhandeling: Expliciete afhandeling van mogelijke fouten en uitzonderingen.
• Commentaar: Aanwezig waar de code niet duidelijk is of om de logica uit te leggen.
• Consistente stijl: Eendrachtige stijl van formatteren en benoemen in het hele project.
• Minimaliseren van code duplicatie: Vermijden dat dezelfde codeblokken worden herhaald.

# Goed voorbeeld van decompositie en duidelijke namen
def calculate_average(numbers):
    """Bereken het gemiddelde van een lijst getallen."""
    if not numbers:
        return 0
    total = sum(numbers)
    return total / len(numbers)

def process_data(data):
    # We gaan ervan uit dat 'data' een lijst van lijsten met getallen is
    averages = []
    for row in data:
        avg = calculate_average(row)
        averages.append(avg)
    return averages

Slechte criteria:

• Onduidelijkheid: De code is moeilijk te begrijpen vanwege verwarrende logica, onduidelijke namen of gebrek aan structuur.
• "Spaghetticode": Veel overgangen en afhankelijkheden die het moeilijk maken de uitvoering te volgen.
• "Lazo"-code: Lange, monolithische functies die veel niet-verwante taken uitvoeren.
• Gebruik van "magische getallen": Onverklaarde numerieke constanten in de code.
• Gebrek aan foutafhandeling: Het programma "crasht" bij onvoorziene situaties.
• Code duplicatie: Identieke of zeer vergelijkbare blokken code worden op verschillende plaatsen herhaald.
• Inconsistente stijl: Verschillende opmaak en naamgeving die het lezen bemoeilijken.

# Slecht voorbeeld van "lazo" en magische getallen
def process(d):
    t = 0
    for r in d:
        s = 0
        c = 0
        for n in r:
            s += n
            c += 1
        if c > 0:
            t += s / c
    return t / len(d) if len(d) > 0 else 0

Vergelijking:

Goede criteria	Slechte criteria
Leesbaarheid	Onduidelijkheid ("spaghetticode", "lazo")
Begrijpelijke variabelen en functies	Onleesbare namen
Decompositie	Monolithische functies
Afwezigheid van globale variabelen	Overmatig gebruik van globale variabelen
Expliciete foutafhandeling	Ontbrekende foutafhandeling
Commentaar waar nodig	Ontbrekende commentaren
Consistente stijl	Inconsistente stijl
Minimaliseren van code duplicatie	Duplicatie van code