Wat zijn belangrijke softwareontwerpprincipes (DRY, KISS, YAGNI)?

Question

Accepted Answer

Naast specifieke patronen sturen **ontwerpprincipes** zoals **DRY**, **KISS**, **YAGNI** en anderen het schrijven van goede code. Deze gemakkelijk te onthouden principes bevatten fundamentele wijsheid over eenvoud, het vermijden van duplicatie en niet te veel bouwen.

## Kernprincipes

```text
DRY (Don't Repeat Yourself) → avoid DUPLICATION → each piece of knowledge has ONE
  authoritative representation (duplication → bugs/changes in many places)
KISS (Keep It Simple, Stupid) → favor SIMPLICITY → simple solutions are easier to
  understand, maintain, and debug (avoid unnecessary complexity)
YAGNI (You Aren't Gonna Need It) → don't build features/flexibility you don't NEED yet →
  avoid speculative generality (build what's needed, not what might be needed)
```

## Andere belangrijke principes

```text
✓ SEPARATION OF CONCERNS → divide a system into distinct parts with clear responsibilities
✓ HIGH COHESION, LOW COUPLING → related things together; minimize dependencies between parts
✓ COMPOSITION over inheritance → prefer composing behavior over deep inheritance hierarchies
✓ LEAST ASTONISHMENT → code should behave as expected (no surprises)
✓ Encapsulation; single source of truth; fail fast; principle of least privilege
```

## Evenwicht tussen principes

```text
⚠️ Principles can sometimes CONFLICT or be over-applied:
  → DRY vs simplicity → don't over-abstract to avoid tiny duplication (sometimes a little
    duplication is simpler than the wrong abstraction)
  → KISS/YAGNI vs flexibility → don't under-build genuinely-needed flexibility
→ apply principles with JUDGMENT and balance → they're guidelines, not absolute rules
```

## Waarom het belangrijk is

Het begrijpen van belangrijke softwareontwerpprincipes is waardevol kennis op senior niveau omdat ze **fundamentele wijsheid bevatten voor het schrijven van goede code** die van toepassing is op patronen en talen, dus ze zijn breed relevante ontwerprichtlijnen.

Principes zoals DRY, KISS en YAGNI distilleren kernwijsheid van softwareontwerp in gemakkelijk te onthouden, veel geciteerde richtlijnen.

Het begrijpen van de **kernprincipes** — **DRY** (het voorkomen van duplicatie zodat elk stukje kennis één gezaghebbende weergave heeft, omdat duplicatie bugs en verspreide wijzigingen veroorzaakt), **KISS** (eenvoud prefereren omdat eenvoudige oplossingen gemakkelijker te begrijpen, onderhouden en debuggen zijn) en **YAGNI** (niet bouwen aan functies of flexibiliteit die je nog niet nodig hebt, om speculatieve over-engineering te vermijden) — biedt fundamentele richtlijnen die overal toepasbaar zijn.

Het begrijpen van **andere belangrijke principes** — **scheiding van belangen**, **hoge cohesie en lage koppeling** (gerelateerde dingen bij elkaar, minimale afhankelijkheden tussen onderdelen — fundamenteel voor goed ontwerp), **compositie boven overerving**, minst verbazing, inkapseling en enkele bron van waarheid — verbreedde de ontwerpwijsheid.

Crucciaal is dat het begrijpen van **balans tussen principes** rijpe oordeelsvorming weerspiegelt: principes kunnen conflicteren of te veel worden toegepast (DRY versus eenvoud — soms is een beetje duplicatie beter dan de verkeerde abstractie; KISS/YAGNI versus werkelijk nodig flexibiliteit — bouw niet te weinig van wat echt nodig is), dus ze zijn **richtlijnen om met oordeel toe te passen, geen absolute regels**.

Dit evenwichtige begrip — de principes kennen maar ze doordacht in plaats van dogmatisch toepassen — is het kenmerk van rijpe ontwerpzin.

Deze principes zijn breed toepasbare, taal- en patroon-onafhankelijke wijsheid die het schrijven van goede code stuurt.

Omdat deze ontwerpprincipes (DRY, KISS, YAGNI, scheiding van belangen, lage koppeling) fundamentele, breed toepasbare wijsheid bevatten voor het schrijven van goede code, en omdat het toepassen ervan met evenwichtig oordeel (erkennend dat het richtlijnen zijn die kunnen conflicteren of te veel kunnen worden toegepast) rijpe ontwerpzin weerspiegelt, en omdat het veel geciteerde richtlijnen zijn, is het begrijpen van belangrijke softwareontwerpprincipes waardevol kennis op senior niveau — fundamentele, breed toepasbare wijsheid voor het schrijven van goede code, belangrijk voor patronen en talen, en weerspiegelend het rijpe ontwerpuordeel (de principes kennen en ze met balans toepassen) dat van senior developers wordt verwacht die goed softwareontwerp schrijven en begeleiden.