Hva er viktige programvaredesignprinsipper (DRY, KISS, YAGNI)?

Question

Accepted Answer

Beyond specific patterns, **designprinsipper** som **DRY**, **KISS**, **YAGNI**, og andre veileder oss i å skrive god kode. Disse minnerike prinsippene fanger grunnleggende visdom om enkelthet, unngåelse av duplikasjon, og å ikke over-bygge.

## Kjerneprinsipper

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

## Andre viktige prinsipper

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

## Balansering av prinsipper

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

Å forstå viktige programvaredesignprinsipper er verdifull kunnskap på seniornivå fordi de fanger **grunnleggende visdom for å skrive god kode** som gjelder på tvers av mønstre og språk, så de er bredt anvendelig designveiledning.

Prinsipper som DRY, KISS, og YAGNI destillerer grunnleggende programvaredesignvisdom til minnerike, vidt refererte retningslinjer.

Å forstå **kjernprinsippene** — **DRY** (unngå duplikasjon slik at hver del av kunnskapen har én autoritativ representasjon, siden duplikasjon forårsaker bugs og spredte endringer), **KISS** (favoriser enkelthet siden enkle løsninger er lettere å forstå, vedlikeholde, og feilsøke), og **YAGNI** (ikke bygg funksjoner eller fleksibilitet du ikke ennå trenger, unngå spekulativ over-engineering) — gir grunnleggende veiledning som gjelder overalt.

Å forstå **andre viktige prinsipper** — **adskillelse av bekymringer**, **høy kohesjon og lav koblingsgrad** (relaterte ting sammen, minimale avhengigheter mellom deler — grunnleggende for god design), **sammensetning over arv**, minste overraskelse, innkapsling, og enkelt sannhetskilde — utvider designvisdommen.

Viktigst er å forstå **balanseringsprinsippene**, noe som reflekterer modenhet: prinsipper kan komme i konflikt eller bli over-anvendt (DRY vs enkelthet — noen ganger er litt duplikasjon bedre enn feil abstraksjon; KISS/YAGNI vs genuint nødvendig fleksibilitet — ikke under-bygg det som virkelig trengs), så de er **retningslinjer som skal brukes med skjønn, ikke absolutte regler**.

Denne balanserte forståelsen — å kjenne prinsippene men bruke dem gjennomtenkt i stedet for dogmatisk — er kjennetegnet på modendesignsans.

Disse prinsippene er bredt anvendelig, språk- og mønstuavhengig visdom som veileder oss i å skrive god kode.

Siden disse designprinsippene (DRY, KISS, YAGNI, adskillelse av bekymringer, lav koblingsgrad) fanger grunnleggende, bredt anvendelig visdom for å skrive god kode, og siden å bruke dem med balansert skjønn (erkjenne at de er retningslinjer som kan komme i konflikt eller bli over-anvendt) reflekterer modendesignsans, og siden de er vidt referert veiledning, er det å forstå viktige programvaredesignprinsipper verdifull kunnskap på seniornivå — grunnleggende, bredt anvendelig visdom for å skrive god kode, viktig på tvers av mønstre og språk, og reflekterer den modendesignrettslinjen (å kjenne prinsippene og bruke dem med balanse) som forventes av seniorkodere som skriver og veileder god programvaredesign.