Hvad er vigtige softwaredesignprincipper (DRY, KISS, YAGNI)?

Question

Accepted Answer

Beyond specific patterns, **design principles** like **DRY**, **KISS**, **YAGNI**, og andre vejleder skrivning af god kode. Disse let-huske principper fanger fundamental visdom om enkelhed, undgåelse af duplikering og ikke at over-bygge.

## Core principles

```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)
```

## Other important principles

```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
```

## Balancing principles

```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
```

## Hvorfor det betyder noget

At forstå vigtige softwaredesignprincipper er værdifuld viden på seniorniveau, fordi de fanger **fundamental visdom for at skrive god kode**, som gælder på tværs af patterns og programmeringssprog, så de er bredt vigtig designvejledning.

Principper som DRY, KISS og YAGNI destillerer kernedelen af softwaredesignvisdom til let-huske, bredt-refererede retningslinjer.

At forstå de **vigtigste principper** — **DRY** (undgåelse af duplikering, så hvert stykke viden har en autoritativ repræsentation, da duplikering forårsager fejl og spredt ændringer), **KISS** (favorisering af enkelhed, da simple løsninger er lettere at forstå, vedligeholde og fejlfinde), og **YAGNI** (ikke at bygge funktioner eller fleksibilitet, som du ikke endnu har brug for, undgåelse af spekulativ over-engineering) — giver fundamental vejledning, som er anvendelig overalt.

At forstå **andre vigtige principper** — **separation of concerns**, **høj kohesion og lav kobling** (relaterede ting sammen, minimale afhængigheder mellem dele — fundamental for god design), **composition over inheritance**, least astonishment, encapsulation og single source of truth — udvider designvisdommen.

Vigtigst af alt afspejler forståelse af **balancing principles** modent skøn: principper kan være i konflikt eller over-anvendes (DRY vs. enkelhed — nogle gange er lidt duplikering bedre end den forkerte abstraktion; KISS/YAGNI vs. ægte behov for fleksibilitet — underbygn ikke det, som er ægte behov), så de er **retningslinjer at anvende med skøn, ikke absolutte regler**.

Denne balancerede forståelse — at kende principperne men anvende dem tankefuldt snarere end dogmatisk — er mærket på modent designsyn.

Disse principper er bredt anvendelig, sprog- og pattern-uafhængig visdom, som vejleder skrivning af god kode.

Da disse designprincipper (DRY, KISS, YAGNI, separation of concerns, lav kobling) fanger fundamental, bredt-anvendelig visdom for at skrive god kode, og da anvendelse af dem med balanceret skøn (anerkendelse af at de er retningslinjer, der kan være i konflikt eller over-anvendes) afspejler modent designsyn, og da de er bredt-refererede vejledning, er forståelse af vigtige softwaredesignprincipper værdifuld viden på seniorniveau — fundamental, bredt-anvendelig visdom for at skrive god kode, vigtig på tværs af patterns og programmeringssprog, og afspejler det modne designskøn (at kende principperne og anvende dem med balance), som forventes af seniorrekvellinger, der skriver og vejleder god softwaredesign.