1.4-Software-Development-Principles

Principes voor het schrijven van software

Inleiding

Er zijn twee belangrijke principes die je altijd in je achterhoofd moet houden bij het schrijven van software.

1. KISS
2. DRY

KISS

KISS staat voor “Keep It Simple, Stupid” of “Keep It Small and Simple” en is een ontwerpprincipe dat benadrukt dat systemen beter functioneren als ze eenvoudig zijn gehouden in plaats van complex. De essentie van KISS is het vermijden van onnodige complexiteit.

Het KISS-principe in software engineering benadrukt de waarde van eenvoud in ontwerp en implementatie. Door code eenvoudig, rechttoe rechtaan en goed gestructureerd te houden, wordt deze leesbaarder, onderhoudbaarder en vaak efficiënter. Dit is een fundamentele benadering die vooral nuttig is voor beginnende software-engineers om goede programmeergewoonten te ontwikkelen.

Complexiteit meten

Hoe weet je nou of jouw software te complex is geworden? Een maatstaf hiervoor is “cyclomatic complexity”. (Cyclomatische complexiteit)

Cyclomatische complexiteit is een maatstaf binnen software ontwikkeling die wordt bepaald door het aantal verschillende paden die jouw code toestaat. Bijvoorbeeld, een eenvodig if-then-else statement zal altijd twee paden aanbieden. Ook als er geen else gedeelte is. switch statements voegen een pad toe voor elke optie, en een default pad. En tenslotte loops vermenigvuldingen de complexiteit met de met het aantal paden binnen de loop.

Het gaat hierbij niet alleen om het tellen van het aantal instructies, maar ook om hoe die instructies met elkaar interacteren. Het helpt om duidelijk vast te stellen wanneer een stuk code duidelijk niet makkelijk onderhoudbaar, of testbaar meer is.

Dus de conclusie is dat code met een hoge cyclomatische complexiteit gebruikelijk veel moeilijker te onderhouden is. Zulke code heeft meet tests nodig om te bevestigen dat alle paden (of taken) afgedekt zijn. Zie ook de lessen over unittesten en branch coverage. De video toont branch coverage vanaf tijdstip 13:00.

Plugins for IntelliJ

Ga naar het settings scherm en kies voor plugins:

Wanneer je de CodeMetrics tool, uit de marktplaats, kiest dan wordt voortaan jouw code voorzien met “suggesties” zoals deze:

Alles onder de 5 is helemaal okee. Boven de 15 moet je misschien wat dingen aanpassen. (Als de code er al buitengewoon simpel voor jou uit ziet, dan mag je de plugin negeren.)

DRY

DRY, wat staat voor “Don’t Repeat Yourself”. Het is een fundamenteel principe in software-ontwikkeling dat zegt dat je geen of zo min mogelijk herhaling van in je code moet hebben. Het idee is om elk stukje kennis (data) of logica op één enkele plaats in de code te houden. Dit verhoogt de onderhoudbaarheid, vermindert fouten en maakt de code over het algemeen schoner en makkelijker te begrijpen.

Hier is een eenvoudig voorbeeld in Java om het DRY-principe te illustreren.

Stel, je hebt een programma waarin je meerdere keren een specifieke berekening uitvoert:

public class NonDryExample {

    public static void main(String[] args) {
        int num1 = 5;
        int num2 = 10;
        int som1 = num1 * 2 + num2 * 2;

        int num3 = 15;
        int num4 = 20;
        int som2 = num3 * 2 + num4 * 2;

        // More code that repeats the caclulationt...
    }
}

In dit voorbeeld wordt dezelfde berekening (num * 2 + andernum * 2) meerdere keren herhaald. Dit is niet in overeenstemming met het DRY-principe.

Hoe doe je dit beter?

Een betere aanpak is om een methode te maken voor de herhaalde berekening:

public class DryExample {

    public static void main(String[] args) {
        int num1 = 5;
        int num2 = 10;
        int som1 = calcSum(num1, num2);

        int num3 = 15;
        int num4 = 20;
        int som2 = calcSum(num3, num4);

        // The same method can now be used for future calculations...
    }

    private static int calcSum(int a, int b) {
        return a * 2 + b * 2;
    }
}

In dit aangepaste voorbeeld is er een methode calcSum gecreëerd, die de herhaalde berekening uitvoert. Elke keer dat je deze berekening nodig hebt, roep je gewoon deze methode aan. Dit maakt de code niet alleen korter en schoner, maar betekent ook dat als je de berekeningslogica moet wijzigen, je dat maar op één plek hoeft te doen.

Voordelen van DRY
Onderhoudbaarheid: Wijzigingen hoeven slechts op één plek te worden gemaakt, waardoor de kans op fouten bij het aanpassen van de code vermindert.
Leesbaarheid: De code wordt schoner en makkelijker te lezen. Herbruikbaarheid: Door logica in methoden te encapsuleren, wordt het gemakkelijker om deze in verschillende delen van de applicatie te hergebruiken.

Het DRY-principe is een van de basis principes van goede softwareontwikkelingspraktijken en draagt bij aan het creëren van efficiënte, foutbestendige en onderhoudbare code.

DRY bij kennis

Het DRY-principe is niet alleen van toepassing op code-logica, maar ook op kennis binnen een applicatie. “Kennis” kan verwijzen naar gegevens, configuratie, of zelfs documentatie. Het idee is om een enkele bron van waarheid (singel soure of thruth) te hebben voor elk stukje informatie.

Stel, je hebt een eenvoudige Java-klasse waarin je op meerdere plekken dezelfde waarde gebruikt:

public class NonDryKnowledgeExample {

    public void displaySettings() {
        System.out.println("Maximaal aantal gebruikers: 100");
        // ... other settings
    }

    public void checkUserLimit() {
        if (currentUsers > 100) {
            System.out.println("Gebruikerslimiet bereikt");
        }
        // ... other logic
    }
}

In dit voorbeeld wordt de waarde 100 (het maximale aantal gebruikers) op meerdere plaatsen gebruikt. Als deze limiet verandert, moet je deze waarde op alle plaatsen bijwerken.

Voorbeeld Met DRY (Kennis)
Een betere aanpak is om deze waarde maar op één plek te definieren en daarna te hergebruiken:

public class DryKnowledgeExample {

    private static final int MAX_USERS = 100;

    public void displaySettings() {
        System.out.println("Maximaal aantal gebruikers: " + MAX_USERS);
        // ... other settings
    }

    public void checkUserLimit() {
        if (currentUsers > MAX_USERS) {
            System.out.println("Gebruikerslimiet bereikt");
        }
        // ... other logic
    }
}

Hier wordt de maximale waarde als een constante MAX_USERS gedefinieerd. Deze waarde wordt vervolgens door de hele klasse heen gebruikt. Als je besluit om de limiet te veranderen, hoef je alleen de waarde van MAX_USERS te wijzigen.

Conclusies

Langzaam maar zeker zul je steeds complexere applicaties schrijven tijdens deze module en de modules in jaar twee. Daarom zul je ook steeds meer redenen vinden om jouw kennis op te delen in eenvoudige methoden. Het is onze intentie dat deze vaardigheid zich steeds meer zal ontwikkelen in de komende jaren als je meer ervaren ontwikkelaars ontmoet die andere tips en truuks hebben geleerd, of mogelijk hele goede redenen om deze regels te breken.

Voorlopig betekent dit dat we tijdens het examen punten zullen afnemen wanneer je de regels breekt. Dus hou rekening met dubbele stukken code tijdens jouw opgaven, en herschijf zulke stukken zodat je een enkele oplossing die in beide situaties toegpast kan worden. (IntelliJ zelf biedt opmerkingen aan over code duplicatie.)