Code that fits in your head - Heuristiken für die Softwareentwicklung: Komplexität reduzieren | Legacy Code beherrschen | Performance optimieren

Code that fits in your head - Heuristiken für die Softwareentwicklung: Komplexität reduzieren | Legacy Code beherrschen | Performance optimieren

by Mark Seeman
Released July 2022
Publisher(s): mitp Verlag
ISBN: 9783747505168

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

  • Techniken und Konzepte für nachhaltige Softwareentwicklung sowie sauberen und wartbaren Code
  • Reduktion von Komplexität, strukturierte Arbeitsabläufe und effiziente Fehlerbehandlung
  • Mit Auszügen aus einem vollständigen Beispielprojekt inklusive Code zum Download

»Mark Seemann ist dafür bekannt, komplexe Konzepte anschaulich und präzise zu erläutern. In diesem Buch kondensiert er seine weitreichende Erfahrung in der Softwareentwicklung zu praktischen, pragmatischen Techniken für nachhaltigen und gut lesbaren Code. Dieses Buch ist ein Must Read für jeden Programmierer.«

– Scott Wlaschin, Autor von »Domain Modeling Made Functional«

Dieses Buch ist ein praktischer Leitfaden für das Schreiben von nachhaltigem Programmcode und die Reduktion von Komplexität. So können Sie verhindern, dass Softwareprojekte langfristig außer Kontrolle geraten.

Mark Seemann unterstützt seit Jahrzehnten Softwareentwickler-Teams bei der erfolgreichen Umsetzung ihrer Projekte. In diesem Buch begleitet er Sie von den ersten Codezeilen bis zum Deployment und zeigt Ihnen, wie Sie im Entwicklungsprozess effizient und nachhaltig bleiben, wenn Sie neue Funktionalitäten implementieren. Dabei legt er auch Wert auf Fehlerbehandlung und disziplinübergreifende Themen. Er gibt Ihnen wertvolle Hinweise, Techniken und Arbeitsabläufe für alle wichtigen Kernprobleme an die Hand: von der Verwendung von Checklisten bis zur Teamarbeit, von Kapselung bis zur verteilten Programmierung, von API-Design bis zu Unit Testing.

Seemann veranschaulicht seine Konzepte anhand von Codebeispielen aus einem vollständigen Projektbeispiel in C#. Der Code ist so geschrieben, dass er gut verständlich für jeden ist, der eine objektorientierte Programmiersprache verwendet, einschließlich Java, C++ und Python. Der gesamte Code steht zur weiteren Erkundung zum Download bereit.

Wenn Sie jemals negative Erfahrungen bei der Umsetzung von Softwareprojekten oder mit schlecht wartbarem Legacy Code gemacht haben, wird dieses Praxisbuch Ihnen helfen, solchen Schwierigkeiten ab sofort aus dem Weg zu gehen.

Aus dem Inhalt:
  • Den passenden Workflow wählen und schlechten Metaphern entkommen, die nicht funktionieren
  • Mit Checklisten mehr Freiheiten schaffen und das Ergebnis verbessern, indem Sie die Fähigkeiten nutzen, über die Sie bereits verfügen
  • Code Rot und unnötige Komplexität vermeiden
  • Bessere Techniken meistern und neue Routinen bei der Programmierung etablieren
  • Neue Wege für effektivere und schnellere Fehlerbehandlung
  • Höhere Produktivität in Bezug auf Performance und Sicherheit

Table of contents

  1. Stimmen zum Buch
  2. Code That Fits in Your Head
  3. Impressum
  4. Vorwort des Herausgebers der englischen Ausgabe
  5. Einleitung
    1. Wer dieses Buch lesen sollte
      1. Voraussetzungen
      2. Ein Hinweis für Softwarearchitekten
    2. Aufbau des Buchs
      1. Über den Codestil
      2. var verwenden oder var nicht verwenden
      3. Code-Listings
    3. Hinweis zur Bibliografie
      1. Eigene Zitate
    4. Danksagung
  6. Über den Autor
  7. Teil I: Beschleunigung
  8. Kapitel 1: Kunst oder Wissenschaft?
    1. 1.1 Bau eines Hauses
      1. 1.1.1 Das Problem mit Projekten
      2. 1.1.2 Das Problem mit Phasen
      3. 1.1.3 Abhängigkeiten‌
    2. 1.2 Kultivieren eines Gartens
      1. 1.2.1 Was lässt einen Garten gedeihen?
    3. 1.3 Der Weg zur Ingenieurswissenschaft
      1. 1.3.1 Software als Kunsthandwerk
      2. 1.3.2 Heuristik
      3. 1.3.3 Ältere Vorstellungen von Software Engineering
      4. 1.3.4 Fortschritte beim Software Engineering
    4. 1.4 Fazit
  9. Kapitel 2: Checklisten
    1. 2.1 Eine Gedächtnisstütze
    2. 2.2 Checkliste für eine neue Codebasis
      1. 2.2.1 Git verwenden
      2. 2.2.2 Build automatisieren
      3. 2.2.3 Alle Fehlermeldungen‌ aktivieren
    3. 2.3 Überprüfungen zu einer vorhandenen Codebasis hinzufügen
      1. 2.3.1 Schrittweise Verbesserungen
      2. 2.3.2 Hacken Sie Ihre Organisation
    4. 2.4 Fazit
  10. Kapitel 3: Komplexität in den Griff bekommen
    1. 3.1 Ziel
      1. 3.1.1 Nachhaltigkeit
      2. 3.1.2 Nutzwert
    2. 3.2 Warum Programmieren schwierig ist
      1. 3.2.1 Die Gehirn-Metapher
      2. 3.2.2 Code wird häufiger gelesen als geschrieben
      3. 3.2.3 Verständlichkeit
      4. 3.2.4 Geistige Arbeit
    3. 3.3 Software Engineering
      1. 3.3.1 Beziehung zur Informatik
      2. 3.3.2 Menschenfreundlicher Code
    4. 3.4 Fazit
  11. Kapitel 4: Vertical Slice
    1. 4.1 Beginnen Sie mit funktionierender Software
      1. 4.1.1 Vom Dateneingang zur dauerhaften Datenspeicherung‌
      2. 4.1.2 Minimaler Vertical Slice
    2. 4.2 Laufendes Skelett
      1. 4.2.1 Charakterisierungstest
      2. 4.2.2 Arrange, Act, Assert
      3. 4.2.3 Lockerung der statischen Analyse
    3. 4.3 Von außen nach innen
      1. 4.3.1 JSON entgegennehmen
      2. 4.3.2 Eine Reservierung vornehmen
      3. 4.3.3 Unit-Test
      4. 4.3.4 DTO und Domänenmodell
      5. 4.3.5 Fake-Objekt
      6. 4.3.6 Schnittstelle für das Repository
      7. 4.3.7 Objekte im Repository erstellen
      8. 4.3.8 Abhängigkeiten konfigurieren
    4. 4.4 Vervollständigen Sie den Slice
      1. 4.4.1 Schema
      2. 4.4.2 SQL-Repository
      3. 4.4.3 Konfiguration mit der Datenbank
      4. 4.4.4 Führen Sie einen Smoke Test durch
      5. 4.4.5 Test der Außengrenze mit einer Fake-Datenbank
    5. 4.5 Fazit
  12. Kapitel 5: Kapselung
    1. 5.1 Speichern Sie die Daten
      1. 5.1.1 Prämisse der Priorität der Transformation
      2. 5.1.2 Parametrisierter Test
      3. 5.1.3 DTO ins Domänenmodell kopieren
    2. 5.2 Validierung
      1. 5.2.1 Ungültige oder fehlende ‌Datumsangaben
      2. 5.2.2 Rot-Grün-Refactor
      3. 5.2.3 Natürliche Zahlen
      4. 5.2.4 Robustheitsgrundsatz
    3. 5.3 Schutz von Invarianten
      1. 5.3.1 Immer gültig
    4. 5.4 Fazit
  13. Kapitel 6: Triangulierung
    1. 6.1 Kurzzeit- und Langzeitgedächtnis
      1. 6.1.1 Legacy Code und Gedächtnis
    2. 6.2 Kapazität
      1. 6.2.1 Überbuchung
      2. 6.2.2 Advokat des Teufels‌
      3. 6.2.3 Vorhandene Reservierungen
      4. 6.2.4 Advokat des Teufels und Rot-Grün-Refactor
      5. 6.2.5 Wann haben Sie hinreichend viele Tests?
    3. 6.3 Fazit
  14. Kapitel 7: Dekomposition
    1. 7.1 Code Rot
      1. 7.1.1 Schwellenwerte
      2. 7.1.2 Zyklomatische Komplexität
      3. 7.1.3 Die 80/24-Regel
    2. 7.2 Verständlicher Code
      1. 7.2.1 Hexagonale Blumen
      2. 7.2.2 Kohäsion
      3. 7.2.3 Feature-Neid
      4. 7.2.4 Beim Verschieben verlorengegangen
      5. 7.2.5 Parsen, nicht überprüfen
      6. 7.2.6 Fraktale Architektur
      7. 7.2.7 Variablen zählen
    3. 7.3 Fazit
  15. Kapitel 8: API-Design
    1. 8.1 Prinzipien des API-Designs
      1. 8.1.1 Affordanz
      2. 8.1.2 Poka Yoke
      3. 8.1.3 Schreiben Sie für die Leser
      4. 8.1.4 Ziehen Sie sinnvoll benannten Code Kommentaren vor
      5. 8.1.5 Namen ausixen
      6. 8.1.6 Trennung von Befehlen und Abfragen
      7. 8.1.7 Kommunikationshierarchie
    2. 8.2 Beispiel für ein API-Design
      1. 8.2.1 Maître d’hôtel
      2. 8.2.2 Verwendung eines gekapselten Objekts
      3. 8.2.3 Implementierungsdetails
    3. 8.3 Fazit
  16. Kapitel 9: Zusammenarbeit
    1. 9.1 Git
      1. 9.1.1 Commit-Nachrichten
      2. 9.1.2 Continuos Integration
      3. 9.1.3 Kleine Commits
    2. 9.2 Gemeinsame Eigentümerschaft am Code
      1. 9.2.1 Paarprogrammierung
      2. 9.2.2 Mob-Programmierung
      3. 9.2.3 Verzögerungen durch Code-Reviews
      4. 9.2.4 Ablehnung von Änderungen
      5. 9.2.5 Code-Reviews
      6. 9.2.6 Pull-Requests
    3. 9.3 Fazit
  17. Teil II: Nachhaltigkeit
  18. Kapitel 10: Erweiterung des Codes
    1. 10.1 Feature-Flags
      1. 10.1.1 Kalender-Flag
    2. 10.2 Das Strangler-Pattern
      1. 10.2.1 Strangler auf Methodenebene
      2. 10.2.2 Strangler auf Klassenebene
    3. 10.3 Versionierung
      1. 10.3.1 Vorwarnung
    4. 10.4 Fazit
  19. Kapitel 11: Bearbeiten von Unit-Tests
    1. 11.1 Refactoring von Unit-Tests
      1. 11.1.1 Änderung des Sicherheitsnetzes
      2. 11.1.2 Hinzufügen von neuem Testcode
      3. 11.1.3 Refactoring von Test- und Produktionscode trennen
    2. 11.2 Fehlschlagende Tests
    3. 11.3 Fazit
  20. Kapitel 12: Fehlerbehebung
    1. 12.1 Verstehen
      1. 12.1.1 Wissenschaftliche Vorgehensweise
      2. 12.1.2 Vereinfachen
      3. 12.1.3 Quietscheentchen-Debugging
    2. 12.2 Fehler
      1. 12.2.1 Fehler durch Tests reproduzieren
      2. 12.2.2 Langsame Tests
      3. 12.2.3 Nichtdeterministische Fehler
    3. 12.3 Bisektion
      1. 12.3.1 Bisektion mit Git
    4. 12.4 Fazit
  21. Kapitel 13: Trennung von Zuständigkeiten
    1. 13.1 Komposition
      1. 13.1.1 Verschachtelte Komposition
      2. 13.1.2 Sequenzielle Komposition
      3. 13.1.3 Referenzielle Transparenz
    2. 13.2 Cross-Cutting Concerns
      1. 13.2.1 Logging
      2. 13.2.2 Decorator
      3. 13.2.3 Was protokolliert werden sollte
    3. 13.3 Fazit
  22. Kapitel 14: Rhythmus
    1. 14.1 Persönlicher Rhythmus
      1. 14.1.1 Zeiteinteilung
      2. 14.1.2 Pausieren
      3. 14.1.3 Zeit wohlüberlegt nutzen
      4. 14.1.4 Blindschreiben
    2. 14.2 Team-Rhythmus
      1. 14.2.1 Regelmäßige Aktualisierung der Abhängigkeiten
      2. 14.2.2 Andere Dinge planen
      3. 14.2.3 Gesetz von Conway
    3. 14.3 Fazit
  23. Kapitel 15: Die üblichen Verdächtigen
    1. 15.1 Performance
      1. 15.1.1 Altlast
      2. 15.1.2 Verständlichkeit
    2. 15.2 Security
      1. 15.2.1 STRIDE
      2. 15.2.2 Spoofing
      3. 15.2.3 Tampering
      4. 15.2.4 Repudiation
      5. 15.2.5 Information Disclosure
      6. 15.2.6 Denial of Service
      7. 15.2.7 Elevation of Privilege
    3. 15.3 Andere Verfahren
      1. 15.3.1 Eigenschaft-basiertes Testen
      2. 15.3.2 Verhaltensbezogene Codeanalyse
    4. 15.4 Fazit
  24. Kapitel 16: Tour
    1. 16.1 Navigation
      1. 16.1.1 Das Gesamtbild erkennen
      2. 16.1.2 Organisation der Dateien
      3. 16.1.3 Details aufspüren
    2. 16.2 Architektur
      1. 16.2.1 Monolith
      2. 16.2.2 Zyklen
    3. 16.3 Verwendung
      1. 16.3.1 Aus Tests lernen
      2. 16.3.2 Schenken Sie den Tests Beachtung
    4. 16.4 Fazit
  25. Anhang A: Liste der Verfahren
    1. A.1 50/72-Regel‌
    2. A.2 80/24-Regel‌
    3. A.3 Abhängigkeiten regelmäßig aktualisieren
    4. A.4 Advokat des Teufels‌
    5. A.5 Arrange, Act, Assert‌
    6. A.6 Ausnahmen von der Regel begründen
    7. A.7 Bedrohungsmodell‌
    8. A.8 Bisektion‌
    9. A.9 Checkliste für eine neue Codebasis‌
    10. A.10 Code-Reviews
    11. A.11 Decorators‌ für Cross-Cutting Concerns
    12. A.12 Feature-Flag‌‌
    13. A.13 Fehler als Tests reproduzieren
    14. A.14 Functional Core, Imperative Shell‌
    15. A.15 Kommunikationshierarchie‌
    16. A.16 Namen ausixen‌
    17. A.17 Parsen, nicht überprüfen‌
    18. A.18 Robustheitsgrundsatz‌
    19. A.19 Rot-Grün-Refactor‌
    20. A.20 Refactoring‌ von Test- und Produktionscode trennen
    21. A.21 Semantische Versionierung
    22. A.22 Slice
    23. A.23 Strangler‌
    24. A.24 Prämisse der Priorität der Transformation‌
    25. A.25 Trennung von Befehlen und Abfragen
    26. A.26 X-getriebene Entwicklung‌
    27. A.27 Zählen der Variablen
    28. A.28 Zyklomatische Komplexität‌
  26. Anhang B: Bibliografie

Product information

  • Title: Code that fits in your head - Heuristiken für die Softwareentwicklung: Komplexität reduzieren | Legacy Code beherrschen | Performance optimieren
  • Author(s): Mark Seeman
  • Release date: July 2022
  • Publisher(s): mitp Verlag
  • ISBN: 9783747505168