Agile Java-Entwicklung in der Praxis

Table of contents

1. Agile Java-Entwicklung in der Praxis
   1. Prolog
   2. Einleitung
      1. Zielgruppe dieses Buchs
      2. Voraussetzungen
      3. Aufbau dieses Buchs
      4. Hinweise zur Lektüre
      5. Hinweise zur Verwendung des Codese
      6. Typografische Konventionene
      7. Danksagunge
   3. I. Die Methodik agiler Softwareentwicklung
      1. 1. Einführung in die agile Entwicklung
         1. Geschichte der agilen Entwicklung
         2. Das Agile Manifest
         3. Die Prinzipien
      2. 2. Die Vorteile agiler Entwicklung
         1. Die Kundensicht
         2. Programmierersicht
         3. Die Projektsicht
         4. Soziale und betriebswirtschaftliche Sicht
      3. 3. Agile Ansätze und traditionelles Vorgehen – eine Abgrenzung
         1. Prozessmodelle
         2. Traditionelle Modelle
         3. Was agile Entwicklung nicht ist
         4. Ausprägungen agiler Entwicklung
      4. 4. Dimensionen agiler Entwicklung
         1. Motivation
         2. Kommunikation
         3. Team
         4. Wissen
         5. Zeit
         6. Die größten Verschwender
      5. 5. Die Durchführung
         1. Aufbauorganisation
         2. Das Release
         3. Die Iteration
         4. Pair Programming
         5. Stand-up-Meetings
         6. Konfigurationsmanagement
         7. Test-Driven Development
         8. Continuous Integration (CI)
         9. Refactoring
         10. Standards
         11. Tracking
         12. Abschluss
      6. 6. Agile Prozesse einführen
         1. Wer überzeugt werden muss
         2. Einführungsstrategien
         3. Fallstricke
         4. Besondere Situationen
   4. II. Eine agile technische Infrastruktur
      1. 7. Ant-Grundlagen
         1. Installationshinweise
         2. Terminologie und Konzept
      2. 8. Versionskontrolle mit Subversion
         1. Versionskontrolle
         2. Subversion
         3. Installation und Konfiguration
         4. Nutzung
         5. Revisionen
         6. Versionierung (Tags)
         7. Separate Entwicklungszweige (Branches)
         8. Locking
         9. Automatisierte Nutzung mit Ant
         10. Zusätzliche Werkzeuge
         11. Zusammenfassung
      3. 9. Komponententests mit JUnit
         1. Komponententests
         2. JUnit
         3. Ein erstes Beispiel
         4. JUnit 3.x vs. JUnit 4.x
         5. Testanatomie
         6. Instanzen und Abhängigkeiten
         7. Testaggregation und Nebenläufigkeit
         8. Welche Artefakte sollte ich testen?
         9. Testautomatisierung und kontinuierliche Integration mit Ant
         10. Test-Driven Development mit JUnit
         11. Zusammenfassung
      4. 10. Testabdeckung mit EMMA und JUnit
         1. Installation und Beispiel
         2. Automatisierte Nutzung via Ant
         3. Testabdeckung
         4. Zusammenfassung
      5. 11. Der Einsatz von Mock-Objekten mit EasyMock
         1. Von Mocks und Dummys
         2. EasyMock installieren
         3. Erstes Szenario: »Wegmocken« von Callbacks
         4. Zweites Szenario: »Wegmocken« einer ressourcenintensiven DB-Schnittstelle
         5. Zusammenfassung
      6. 12. Komponententests mit TestNG
         1. Steckbrief
         2. Ein Beispiel: Agile, nebenläufige, gruppierte Verarbeitung
         3. Aufruf der Tests: Das Build-Skript
         4. Zusammenfassung
      7. 13. GUIs testen mit Jemmy
         1. Swing
         2. Einführung in Jemmy
         3. Ein ausführliches Beispiel: Testen der Filterung bei Tabellen
         4. Zusammenfassung
      8. 14. Webanwendungen testen mit Selenium
         1. Architektur von Webanwendungen
         2. Die Arbeitsweise von Selenium
         3. Selenium IDE
         4. Selenium RC – Remote Control
         5. Kontinuierliche Integration mit Ant
         6. Zusammenfassung
      9. 15. Akzeptanztests mit Fit
         1. Akzeptanztests
         2. Einführung in Fit
         3. Vorgehen
         4. Die verschiedenen Fixtures
         5. Ein Rundgang: ColumnFixture
         6. Zusammenfassung
      10. 16. Akzeptanztests für Webanwendungen mit WebTest
          1. Überblick
          2. Installation
          3. Ein erstes Beispiel: Der WebTest-Selbsttest
          4. Ein weiteres Beispiel: Auf Googles Spuren
          5. Wiederverwendung
          6. Reporting
          7. Kontinuierliche Integration
          8. Zusammenfassung
      11. 17. Projektkommunikation mit Trac
          1. Wikis
          2. Trac
          3. Zusammenfassung
      12. 18. Ant – Teil 2: Praktische Einsatzszenarien
          1. Das fundamentale Ant-Gerüst für einen Entwicklungszyklus
          2. Erstes Szenario: »Continuous Integration« auf dem Integrationsrechner
          3. Zweites Szenario: »Continuous Integration« auf einem Arbeitsplatzrechner
          4. Drittes Szenario: »Single Code Basis«-Redundanzen eliminieren unter CVS
          5. Viertes Szenario: Coding Guidelines überprüfen
          6. Fünftes Szenario: HotSwap
          7. Best Practices und Ant-Tipps
          8. Zusammenfassung
      13. 19. Kontinuierliche Integration mit CruiseControl
          1. Der pragmatische Ansatz: cron
          2. Der umfassende Ansatz: CruiseControl
          3. Zusammenfassung
      14. 20. Der Einsatz von Maven für Build-Prozesse
          1. Funktionsumfang
          2. Architektur
          3. Prinzipien
          4. Die ersten Schritte
          5. Das POM
          6. Phase und Goal
          7. Lifecyles
          8. Agile Entwicklung mit Maven
          9. Zusammenfassung
      15. A. Weiterführende Literatur
          1. Zur Methodik
          2. Peopleware – der Faktor Mensch
          3. Testen
          4. Fit
          5. Refactoring
          6. TestNG
          7. Ant, Maven
          8. Subversion
   5. Kolophon