Was ist Code Hygiene?
Code Hygiene ist die kontinuierliche Pflege der technischen Sauberkeit. Sie fragt nicht nach Architektur oder Design, sondern:
- Sind Dateien überschaubar?
- Sind Verantwortlichkeiten sichtbar?
- Sind offensichtliche Risiken erkennbar?
- Ist der Code lesbar und wartbar?
Der Code Hygiene Score
Ein normalisierter Wert zwischen 0-100, der die hygienische Sauberkeit einer Code-Datei bewertet.
Formel
Score = Σ (Faktor_i × Gewicht_i) / Σ Gewicht_i
Jeder Faktor wird auf 0-100 normalisiert, bevor er gewichtet wird. Keine versteckten Sprünge, keine magischen Faktoren.
Unterkapitel
- Faktoren - Was wird gemessen
- Normalisierung - Wie werden Rohwerte skaliert
- Gewichtung - Wie stark zählt jeder Faktor
Interpretation
| Score | Hygiene-Status | Bedeutung |
|---|---|---|
| 80-100 | Sauber | Keine Maßnahmen nötig |
| 60-79 | Gepflegt | Kleinere Aufräumarbeiten möglich |
| 40-59 | Vernachlässigt | Aufräumen empfohlen |
| 20-39 | Verschmutzt | Aufräumen erforderlich |
| 0-19 | Kritisch | Sofortige Hygiene-Maßnahmen |
Was der Score leistet
- Kontinuierliche Hygiene-Überwachung
- Trendbeobachtung: „Welche Datei kippt gerade?"
- Review-Unterstützung
- Vergleich ähnlicher Dateien
Was der Score nicht ist
Kein Architektur-Score. Keine Design-Bewertung. Keine Business-Logic-Analyse.
Nur Hygiene: Ordnung, Vergleichbarkeit, Auffälligkeiten sichtbar machen.
Hygiene-Prinzip
Der Code Hygiene Score misst Ordnung und Sauberkeit, nicht Architektur. Die Faktoren beantworten:
- Laufen Dateien aus dem Ruder?
- Sind Verantwortlichkeiten erkennbar?
- Gibt es offensichtliche Risiken?
1. Größen-Hygiene
„Dateien nicht ausufern lassen"
1.1 Lines of Code (LOC)
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Ist die Datei noch überschaubar? |
| Datenquelle | code_analysis.line_count |
| Sauber | ≤ 100 Zeilen |
| Grenze | 600 Zeilen |
1.2 Methoden-Anzahl
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Hat die Klasse zu viele Aufgaben? |
| Datenquelle | code_analysis.functions |
| Sauber | ≤ 5 Methoden |
| Grenze | 20 Methoden |
1.3 Klassen pro Datei
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Eine Datei = Eine Verantwortung? |
| Datenquelle | code_analysis.classes |
| Sauber | 1 Klasse |
| Grenze | 3 Klassen |
2. Kopplungs-Hygiene
„Abhängigkeiten im Griff behalten"
2.1 Dependencies
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Wie viele externe Abhängigkeiten? |
| Datenquelle | code_analysis.uses (use-Statements) |
| Sauber | ≤ 3 Dependencies |
| Grenze | 20 Dependencies |
use-Statements sind ein pragmatischer Hygiene-Proxy. Nicht perfekt, aber messbar.
3. Sicherheits-Hygiene
„Offensichtliche Risiken früh erkennen"
3.1 Hardcoded Secrets
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Liegen Geheimnisse offen im Code? |
| Erkennung | Regex: Passwörter, API-Keys, Tokens, IPs |
| Sauber | 0 Funde |
| Kritisch | Jeder Fund = schwere Hygiene-Verletzung |
Härtung: Bei Secrets → Score ≤ 20 (Hard Fail)
3.2 Magic Numbers
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Sind Konstanten benannt? |
| Erkennung | Regex: 100, 1000, 60, 24, 365, etc. |
| Sauber | 0 Funde |
| Ausnahme | Config-Dateien ignoriert |
Niedrig gewichtet. Lesbarkeit, nicht Sicherheit.
4. Statische Analyse (geplant)
„Technische Schulden sichtbar machen"
4.1 PHPStan Errors
| Eigenschaft | Wert |
|---|---|
| Hygiene-Frage | Gibt es Typ-Fehler oder tote Pfade? |
| Status | Geplant (Level 5) |
| Sauber | 0 Errors |
Ohne PHPStan bleibt Hygiene unvollständig, aber nicht falsch.
Zusammenfassung
| Kategorie | Faktoren | Hygiene-Zweck | Status |
|---|---|---|---|
| Größe | LOC, Methoden, Klassen | Überschaubarkeit | ✓ |
| Kopplung | Dependencies | Änderbarkeit | ✓ |
| Sicherheit | Secrets, Magic Numbers | Risiko-Erkennung | ✓ |
| Statisch | PHPStan | Technische Schulden | ○ |
Prinzip
Jeder Faktor wird auf 0-100 normalisiert:
- 100 = Hygienisch einwandfrei
- 0 = Hygiene-Grenze überschritten
Lineare Interpolation dazwischen. Keine Sprünge, keine Magie.
Normalisierungsformel
Für Metriken wo weniger = sauberer:
normalized = max(0, 100 - ((wert - optimal) / (grenze - optimal)) × 100)
Beispiel LOC:
- optimal = 100, grenze = 600
- Bei 350 LOC: 100 - ((350-100) / 500) × 100 = 50
Normalisierung pro Faktor
Lines of Code
normalize_loc(loc):
if loc ≤ 100: return 100 # sauber
if loc ≥ 600: return 0 # Grenze
return 100 - ((loc - 100) / 500) × 100
| LOC | Score | Status |
|---|---|---|
| 80 | 100 | Sauber |
| 200 | 80 | Gepflegt |
| 350 | 50 | Vernachlässigt |
| 500 | 20 | Verschmutzt |
| 600+ | 0 | Kritisch |
Methoden-Anzahl
normalize_methods(count):
if count ≤ 5: return 100
if count ≥ 20: return 0
return 100 - ((count - 5) / 15) × 100
| Methoden | Score |
|---|---|
| 5 | 100 |
| 10 | 67 |
| 15 | 33 |
| 20+ | 0 |
Klassen pro Datei
normalize_classes(count):
if count == 1: return 100
if count == 2: return 50
if count == 3: return 25
return 0
Dependencies
normalize_deps(count):
if count ≤ 3: return 100
if count ≥ 20: return 0
return 100 - ((count - 3) / 17) × 100
Hardcoded Secrets
normalize_secrets(count):
if count == 0: return 100
if count ≥ 1: return 20 # Hard Fail
Sonderregel: Secrets sind ein Hygiene-Killer. Ein Fund → Score maximal 20.
Magic Numbers
normalize_magic(count):
if count == 0: return 100
if count ≤ 5: return 100 - (count × 10)
return 50 # Floor
Weniger kritisch. Floor bei 50, nicht 0.
Dateityp-Anpassungen
Pragmatische Hygiene berücksichtigt Kontext:
| Dateityp | Anpassung | Begründung |
|---|---|---|
| Controller | Methoden-Grenze: 25 | Mehr Actions normal |
| Entity | LOC-Grenze: 400 | Sollten schlank sein |
| Repository | Methoden-Grenze: 25 | Viele CRUD-Methoden |
| Config | Magic Numbers: ignoriert | Dort gehören sie hin |
| Test | LOC-Grenze: 800 | Test-Setup braucht Platz |
Prinzip
Jeder normalisierte Faktor wird gewichtet. Die Gewichte spiegeln Hygiene-Relevanz, nicht Architektur-Bedeutung.
Standard-Gewichtung
| Faktor | Gewicht | Hygiene-Begründung |
|---|---|---|
| Dependencies | 25% | Kopplung = Hauptursache für Hygiene-Verfall |
| Lines of Code | 20% | Überschaubarkeit der Datei |
| Methoden-Anzahl | 20% | Verantwortlichkeits-Klarheit |
| Hardcoded Secrets | 15% | Sicherheits-Hygiene |
| Klassen pro Datei | 10% | Datei-Kohäsion |
| Magic Numbers | 10% | Lesbarkeit |
Score-Berechnung
hygiene_score = (
deps_normalized × 0.25 +
loc_normalized × 0.20 +
methods_normalized × 0.20 +
secrets_normalized × 0.15 +
classes_normalized × 0.10 +
magic_normalized × 0.10
)
Beispiel: ContentController.php
400 LOC, 16 Methoden, 1 Klasse, 6 Dependencies, 0 Secrets, 2 Magic Numbers
| Faktor | Roh | Normalisiert | × | Gewicht | = | Beitrag |
|---|---|---|---|---|---|---|
| Dependencies | 6 | 82 | × | 0.25 | = | 20.5 |
| LOC | 400 | 40 | × | 0.20 | = | 8.0 |
| Methoden | 16 | 27 | × | 0.20 | = | 5.4 |
| Secrets | 0 | 100 | × | 0.15 | = | 15.0 |
| Klassen | 1 | 100 | × | 0.10 | = | 10.0 |
| Magic | 2 | 80 | × | 0.10 | = | 8.0 |
| Hygiene Score | 66.9 | |||||
Interpretation: Score 67 = „Gepflegt" (60-79)
Dateityp-Modifikatoren
Pragmatische Gewichtsanpassung nach Dateityp:
Controller
| Faktor | Standard | Controller |
|---|---|---|
| Methoden | 20% | 10% |
| Dependencies | 25% | 30% |
Controller haben viele Actions. Dafür ist Kopplung kritischer.
Entity/Model
| Faktor | Standard | Entity |
|---|---|---|
| LOC | 20% | 30% |
| Dependencies | 25% | 15% |
Entities müssen schlank bleiben. Framework-Dependencies sind unvermeidbar.
Repository
| Faktor | Standard | Repository |
|---|---|---|
| Methoden | 20% | 10% |
| LOC | 20% | 30% |
Viele CRUD-Methoden sind normal. LOC-Hygiene wichtiger.
Zukünftige Erweiterung
Bei Integration von PHPStan:
| Faktor | Aktuell | Mit PHPStan |
|---|---|---|
| Dependencies | 25% | 20% |
| LOC | 20% | 15% |
| Methoden | 20% | 15% |
| Secrets | 15% | 12% |
| Klassen | 10% | 8% |
| Magic | 10% | 5% |
| PHPStan | - | 25% |
PHPStan wird hoch gewichtet - statische Analyse ist Kern-Hygiene.