O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Agile Entwicklungspraktiken mit Scrum

Book Description

  • erstes Buch zu Entwicklungspraktiken in Scrum (technisch orientiert) geschrieben von führenden Scrum-Experten im deutschsprachigen Raum mit Fallbeispielen aus der Praxis

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Widmung
  5. Geleitwort
  6. Inhalt
  7. 1 Einleitung
    1. 1.1 Agile Softwarewicklung und Scrum
    2. 1.2 Zielgruppe und Zielsetzung
    3. 1.3 Überblick über das Buch
    4. 1.4 Java als Beispielsprache
    5. 1.5 Danke
  8. 2 Architekturvision
    1. 2.1 Die Architekturvision im Überblick
    2. 2.2 Wünschenswerte Eigenschaften der Vision
      1. 2.2.1 Klar (Clear)
      2. 2.2.2 Von allen mitgetragen (Accepted)
      3. 2.2.3 Kurz und bündig (Short)
    3. 2.3 Beispiel einer Architekturvision
    4. 2.4 Die Erstellung der Architekturvision
    5. 2.5 Die Form der Vision
    6. 2.6 Architekturvision und Legacy-Systeme
    7. 2.7 Zusammenfassung
  9. 3 Inkrementeller Entwurf
    1. 3.1 Der inkrementelle Entwurf im Überblick
    2. 3.2 Flache Aufwandskurve
    3. 3.3 Qualitätskriterien für den inkrementellen Entwurf
    4. 3.4 Entwurfsprinzipien
      1. 3.4.1 Single Responsibility Principle
      2. 3.4.2 Open Closed Principle
      3. 3.4.3 Liskov Substitution Principle
      4. 3.4.4 Interface Segregation Principle
      5. 3.4.5 Dependency Inversion Principle
    5. 3.5 Inkrementeller Entwurf und agile Entwicklungspraktiken
    6. 3.6 Zusammenfassung
  10. 4 Continuous Integration
    1. 4.1 Continuous Integration im Überblick
    2. 4.2 Ein Beispiel
    3. 4.3 Die Continuous-Integration-Umgebung
    4. 4.4 Kontinuierliches Feedback
    5. 4.5 Umgang mit Feedback
      1. 4.5.1 Broken-Windows-Theory
      2. 4.5.2 Stop-the-Line-Prinzip
    6. 4.6 10-Minuten-Build
    7. 4.7 Continuous-Integration-Produkte
    8. 4.8 Feature-Branches und Feature-Flags
    9. 4.9 Continuous Integration und Scrum
      1. 4.9.1 Offenheit und Mut
      2. 4.9.2 Definition of Done
      3. 4.9.3 Sprint-Meetings
      4. 4.9.4 Feedback für die Scrum-Teammitglieder
    10. 4.10 Einführung von Continuous Integration
      1. 4.10.1 Einführung zu Projektbeginn
      2. 4.10.2 Einführung in ein laufendes Projekt
    11. 4.11 Zusammenfassung
  11. 5 Testgetriebene Entwicklung
    1. 5.1 Testgetriebene Entwicklung im Überblick
    2. 5.2 Der Test-Code-Refactor-Zyklus
    3. 5.3 Ein Beispiel für testgetriebene Entwicklung
      1. 5.3.1 Bevor es losgeht
      2. 5.3.2 Schritt 1: Der fehlschlagende Test
      3. 5.3.3 Schritt 2: Alles wird grün
      4. 5.3.4 Schritt 3: Wir räumen auf
      5. 5.3.5 Wir ergänzen den Test
      6. 5.3.6 Ein weiterer Testfall
      7. 5.3.7 Auffinden fehlender Tests
      8. 5.3.8 Refactoring
      9. 5.3.9 Testfälle für existierende Funktionalität
      10. 5.3.10 Testfälle für zufälliges Verhalten
    4. 5.4 Rhythmus
    5. 5.5 Isoliertes Testen mit Attrappen
      1. 5.5.1 Die Falle
      2. 5.5.2 Die Alternative
      3. 5.5.3 Kleine Typologie der Abhängigkeiten
      4. 5.5.4 Was bisher geschah
      5. 5.5.5 Notifications
      6. 5.5.6 Dependencies alias Services
      7. 5.5.7 Adjustments
    6. 5.6 Integrationstests
    7. 5.7 Heuristiken für gute Tests
    8. 5.8 Weiterführende Hinweise
    9. 5.9 Zusammenfassung
  12. 6 Refactoring
    1. 6.1 Refactoring im Überblick
    2. 6.2 Refactoring und Tests
    3. 6.3 Ein Beispiel
    4. 6.4 Kleine Schritte auf dem grünen Pfad
    5. 6.5 Nutzen von Refactoring
    6. 6.6 Risiken von fehlendem Refactoring
    7. 6.7 Wiederholungen? Niemals!
    8. 6.8 SOLIDes Design und Entwurfsmuster
    9. 6.9 Weitere Refactorings
    10. 6.10 Refactoring von Tests
    11. 6.11 Große Refactorings
    12. 6.12 Refactorings und die Definition of Done
    13. 6.13 Refactoring und Teamarbeit
    14. 6.14 Refactoring von Legacy-Code
    15. 6.15 Zusammenfassung
  13. 7 Automatisierte Refactorings
    1. 7.1 Automatisierte Refactorings im Überblick
    2. 7.2 Der Klassiker: Rename
    3. 7.3 Schritt für Schritt
    4. 7.4 Aufspalten
    5. 7.5 Wunderwaffe »Inline«
    6. 7.6 Große Refactorings
    7. 7.7 Parameter
    8. 7.8 Interfaces und Oberklassen
    9. 7.9 Refactoring ohne Tests
    10. 7.10 Gemischtsprachige Systeme und DSLs
    11. 7.11 Grenzen
    12. 7.12 Zusammenfassung
  14. 8 Automatisierte Akzeptanztests
    1. 8.1 Akzeptanztests im Überblick
    2. 8.2 Formulierung guter Akzeptanztests
    3. 8.3 Werkzeuge zur Testautomatisierung
      1. 8.3.1 Auswahlkriterien
      2. 8.3.2 Werkzeuge zur Formulierung von Akzeptanztests
    4. 8.4 Akzeptanztestgetriebe Entwicklung
      1. 8.4.1 Nutzen
      2. 8.4.2 Vorgehen
    5. 8.5 Zusammenfassung
  15. 9 Pair Programming und Collective Ownership
    1. 9.1 Pair Programming im Überblick
    2. 9.2 Nutzen von Pair Programming
    3. 9.3 Rollenwechsel
    4. 9.4 Wechsel des Partners
    5. 9.5 Einstieg in Pair Programming
    6. 9.6 Collective Ownership
    7. 9.7 Pair Programming und Collective Ownership
    8. 9.8 Collective Ownership für große Projekte
    9. 9.9 Zusammenfassung
  16. 10 Dojos und Katas
    1. 10.1 Code-Katas
      1. 10.1.1 Überblick
      2. 10.1.2 Anwendung
    2. 10.2 Coding-Dojos
      1. 10.2.1 Coding-Dojos mit zwei bis vier Teilnehmern
      2. 10.2.2 Coding-Dojos mit drei bis sechs Teilnehmern
      3. 10.2.3 Coding-Dojos mit vier bis 14 Teilnehmern
    3. 10.3 Code-Katas und Coding-Dojos in Scrum
    4. 10.4 Weitere Dojos
    5. 10.5 Zusammenfassung
  17. 11 Modellgetriebene Entwicklung
    1. 11.1 Modellgetriebene Entwicklung im Überblick
    2. 11.2 Ein Beispiel
      1. 11.2.1 Vorgehen
      2. 11.2.2 Sprint 1: Manuelle Programmierung
      3. 11.2.3 Entwicklung einer DSL
      4. 11.2.4 Vom existierenden Code zur DSL
      5. 11.2.5 Ein Codegenerator
      6. 11.2.6 Sprint 2: Modellgetriebene Implementierung
      7. 11.2.7 Weitere Nutzung der DSL
    3. 11.3 Modellgetriebene Entwicklung und agile Entwicklungspraktiken
    4. 11.4 Inkrementelles Vorgehen
      1. 11.4.1 Collective Code Ownership
      2. 11.4.2 Refactoring
      3. 11.4.3 Continuous Integration
    5. 11.5 Zusammenfassung
  18. 12 Verteilte Entwicklung
    1. 12.1 Verteilte und verstreute Featureteams
    2. 12.2 Virtuelles Pair Programming
    3. 12.3 Entwicklertests
    4. 12.4 Akzeptanztests
    5. 12.5 Collective Ownership
    6. 12.6 Refactoring
    7. 12.7 Continuous Integration
    8. 12.8 Projektstart
    9. 12.9 Anpassen der Entwicklungspraktiken
    10. 12.10 Zusammenfassung
  19. 13 Epilog
  20. Anhang
    1. Die Autoren
    2. Literatur
    3. Index