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

Clean Coder - Verhaltensregeln für professionelle Programmierer

Book Description

Erfolgreiche Programmierer haben eines gemeinsam: Die Praxis der Software-Entwicklung ist ihnen eine Herzensangelegenheit. Auch wenn sie unter einem nicht nachlassenden Druck arbeiten, setzen sie sich engagiert ein. Software-Entwicklung ist für sie eine Handwerkskunst.
In Clean Coder stellt der legendäre Software-Experte Robert C. Martin die Disziplinen, Techniken, Tools und Methoden vor, die Programmierer zu Profis machen. Dieses Buch steckt voller praktischer Ratschläge und behandelt alle wichtigen Themen vom professionellen Verhalten und Zeitmanagement über die Aufwandsschätzung bis zum Refactoring und Testen. Hier geht es um mehr als nur um Technik: Es geht um die innere Haltung. Martin zeigt, wie Sie sich als Software-Entwickler professionell verhalten, gut und sauber arbeiten und verlässlich kommunizieren und planen. Er beschreibt, wie Sie sich schwierigen Entscheidungen stellen und zeigt, dass das eigene Wissen zu verantwortungsvollem Handeln verpflichtet.

Großartige Software ist etwas Bewundernswertes: Sie ist leistungsfähig, elegant, funktional und erfreut bei der Arbeit sowohl den Entwickler als auch den Anwender. Hervorragende Software wird nicht von Maschinen geschrieben, sondern von Profis, die sich dieser Handwerkskunst unerschütterlich verschrieben haben. Clean Coder hilft Ihnen, zu diesem Kreis zu gehören. Robert C. „Uncle Bob“ Martin ist seit 1970 Programmierer und bei Konferenzen in aller Welt ein begehrter Redner. Zu seinen Büchern gehören Clean Code – Refactoring, Patterns, Testen und Techniken für sauberen Code und Agile Software Development: Principles, Patterns, and Practices. Als überaus produktiver Autor hat „Uncle Bob“ Hunderte von Artikeln, Abhandlungen und Blogbeiträgen verfasst. Er war Chefredakteur bei The C++ Report und der erste Vorsitzende der Agile Alliance. Martin gründete und leitet die Firma Object Mentor, Inc., die sich darauf spezialisiert hat, Unternehmen bei der Vollendung ihrer Projekte behilflich zu sein.

    In diesem Buch lernen Sie:
  • Was es bedeutet, sich als echter Profi zu verhalten
  • Wie Sie mit Konflikten, knappen Zeitplänen und unvernünftigen Managern umgehen
  • Wie Sie beim Programmieren im Fluss bleiben und Schreibblockaden überwinden
  • Wie Sie mit unerbittlichem Druck umgehen und Burnout vermeiden
  • Wie Sie Ihr Zeitmanagement optimieren
  • Wie Sie für Umgebungen sorgen, in denen Programmierer und Teams wachsen und sich wohlfühlen
  • Wann Sie „Nein“ sagen sollten – und wie Sie das anstellen
  • Wann Sie „Ja“ sagen sollten – und was ein Ja wirklich bedeutet
Aus dem Inhalt:
  • Verantwortung übernehmen
  • Feindliche Rollen
  • Ein Teamplayer sein
  • Verbindliche Sprache
  • Der Flow-Zustand
  • Schreibblockaden
  • Test Driven Development
  • Das Coding Dojo
  • Akzeptanztests
  • Teststrategien
  • Zeitmanagement
  • Aufwandsschätzungen
  • Umgang mit Druck
  • Mentoring, Lehrzeiten und die Handwerkskunst
  • Werkzeuge und Hilfsmittel

Table of Contents

  1. Impressum
  2. Vorwort
  3. Einführung
  4. Danksagungen
  5. Über den Autor
  6. Auf dem Titelbild
  7. Unverzichtbare Einführung
  8. Kapitel 1: Professionalität​
    1. 1.1 Seien Sie vorsichtig, wonach Ihnen verlangt
    2. 1.2 Verantwortung​ übernehmen
    3. 1.3 Erstens: Richte keinen Schaden an​​
      1. 1.3.1 Beschädige nicht die Funktion​​​
      2. 1.3.2 Beschädige nicht die Struktur​​​
    4. 1.4 Arbeitsethik​
      1. 1.4.1 Sie sollten sich in Ihrem Bereich​ auskennen
      2. 1.4.2 Lebenslanges Lernen​
      3. 1.4.3 Praxis​
      4. 1.4.4 Teamwork​
      5. 1.4.5 Mentorenarbeit​
      6. 1.4.6 Sie sollten sich in Ihrem Arbeitsgebiet​ auskennen
      7. 1.4.7 Identifizieren​ Sie sich mit Ihrem Arbeitgeber bzw. Kunden
      8. 1.4.8 Bescheidenheit​
    5. 1.5 Bibliografie
  9. Kapitel 2: Nein sagen
    1. 2.1 Feindliche Rollen​
      1. 2.1.1 Was ist mit dem Warum?
    2. 2.2 Hoher Einsatz​
    3. 2.3 Ein »Teamplayer​« sein
      1. 2.3.1 Versuchen​​
      2. 2.3.2 Passive Aggression​
    4. 2.4 Die Kosten eines Ja​​
      1. Der typische Projektvorschlag​
      2. Zwei Wochen bis Fertigstellung
      3. Den Kunden ist das alles nie so wichtig wie Ihnen
      4. Resultat? Hektik beim Fertigstellen, Schneckentempo auf dem Weg zum Markt
    5. 2.5 Code unmöglich
  10. Kapitel 3: Ja sagen​
    1. 3.1 Verbindliche Sprache
      1. 3.1.1 So erkennt man mangelnde Selbstverpflichtung
      2. 3.1.2 Wie echte Selbstverpflichtung​ klingt
      3. 3.1.3 Zusammenfassung
    2. 3.2 Lernen, wie man »Ja​« sagt
      1. 3.2.1 Die Kehrseite von »Ich versuch’s mal«
      2. 3.2.2 Der Disziplin​ verpflichtet
    3. 3.3 Schlussfolgerung
  11. Kapitel 4: Programmieren​
    1. 4.1 Bereit sein​
      1. 4.1.1 Code um drei Uhr früh​
      2. 4.1.2 Sorgencode​
    2. 4.2 Der Flow-Zustand​
      1. 4.2.1 Musik​
      2. 4.2.2 Unterbrechungen​​
    3. 4.3 Schreibblockaden​
      1. 4.3.1 Kreativer Input​
    4. 4.4 Debugging​
      1. 4.4.1 Zeit zum Debuggen​​
    5. 4.5 Die eigene Energie einteilen​
      1. 4.5.1 Wann man den Stift​ weglegen muss
      2. 4.5.2 Die Heimfahrt​
      3. 4.5.3 Die Dusche​
    6. 4.6 In Verzug​ sein
      1. 4.6.1 Hoffnung​
      2. 4.6.2 Sich beeilen​
      3. 4.6.3 Überstunden​
      4. 4.6.4 Unlautere Ablieferung​
      5. 4.6.5 Definieren​ Sie »fertig und erledigt«
    7. 4.7 Hilfe​
      1. 4.7.1 Anderen helfen​
      2. 4.7.2 Hilfe annehmen​
      3. 4.7.3 Mentorenarbeit​
    8. 4.8 Bibliografie
  12. Kapitel 5: Test Driven Development​
    1. 5.1 The Jury is in
    2. 5.2 Die drei Gesetze​ des TDD
      1. 5.2.1 Die Litanei der Vorteile​
      2. 5.2.2 Die professionelle Option
    3. 5.3 Was TDD nicht ist
    4. 5.4 Bibliografie
  13. Kapitel 6: Praktizieren und Üben​
    1. 6.1 Etwas Hintergrund übers Üben
      1. 6.1.1 22 Nullen
      2. 6.1.2 Durchlaufzeiten​
    2. 6.2 Das Coding Dojo​
      1. 6.2.1 Kata​
      2. 6.2.2 Waza​
      3. 6.2.3 Randori​
    3. 6.3 Die eigene Erfahrung​ ausbauen
      1. 6.3.1 Open Source​
      2. 6.3.2 Ethisch handeln​
    4. 6.4 Schlussfolgerung
    5. 6.5 Bibliografie
  14. Kapitel 7: Akzeptanztests
    1. 7.1 Anforderungen kommunizieren​
      1. 7.1.1 Verfrühte Präzisierung​​
    2. 7.2 Akzeptanztests​
      1. 7.2.1 Die »Definition of Done​«
      2. 7.2.2 Kommunikation​
      3. 7.2.3 Automatisierung​
      4. 7.2.4 Zusätzliche Arbeit​
      5. 7.2.5 Wer schreibt die Akzeptanztest​s und wann?
      6. 7.2.6 Die Rolle des Entwicklers​
      7. 7.2.7 Verhandlungen​ über die Tests und passive Aggression​​
      8. 7.2.8 Akzeptanz- und Unit-Tests​
      9. 7.2.9 GUIs​ und andere Komplikationen
      10. 7.2.10 Andauernde Integration​
    3. 7.3 Schlussfolgerung
  15. Kapitel 8: Teststrategien​
    1. 8.1 Für die Qualitätssicherung​ sollte nichts übrig bleiben
      1. 8.1.1 Die Qualitätssicherung gehört zum Team​
    2. 8.2 Die Pyramide der Testautomatisierung​
      1. 8.2.1 Unit-Tests​
      2. 8.2.2 Komponententests​
      3. 8.2.3 Integrationstests​
      4. 8.2.4 Systemtests​
      5. 8.2.5 Manuelle explorative Tests​​
    3. 8.3 Schlussfolgerung
    4. 8.4 Bibliografie
  16. Kapitel 9: Zeitmanagement​
    1. 9.1 Meetings​
      1. 9.1.1 Absagen​
      2. 9.1.2 Sich ausklinken​
      3. 9.1.3 Tagesordnung​ und Ziel​
      4. 9.1.4 Stand-up-Meeting​s​
      5. 9.1.5 Planungstreffen zur Iteration​
      6. 9.1.6 Retrospektive​ und Demo​ der Iteration
      7. 9.1.7 Auseinandersetzungen​ und Meinungsverschiedenheiten​
    2. 9.2 Fokus​-Manna
      1. 9.2.1 Schlaf​
      2. 9.2.2 Koffein​
      3. 9.2.3 Die Akkus aufladen​
      4. 9.2.4 Muskelfokus​
      5. 9.2.5 Input​ vs. Output
    3. 9.3 Zeitfenster und Tomaten
    4. 9.4 Vermeidung​
      1. 9.4.1 Umkehrung der Prioritäten​
    5. 9.5 Sackgassen​
    6. 9.6 Morast, Moore, Sümpfe und andere Schlamassel
    7. 9.7 Schlussfolgerung
  17. Kapitel 10: Aufwandsschätzungen​
    1. 10.1 Was eine Aufwandsschätzung​ ist
      1. 10.1.1 Ein Commitment​
      2. 10.1.2 Eine Aufwandsschätzung​
      3. 10.1.3 Implizierte Commitment​s​
    2. 10.2 PERT
    3. 10.3 Aufgaben​ schätzen
      1. 10.3.1 Wideband Delphi​
    4. 10.4 Das Gesetz der großen Zahlen​
    5. 10.5 Schlussfolgerung
    6. 10.6 Bibliografie
  18. Kapitel 11: Äußerer Druck​
    1. 11.1 Druck​ vermeiden
      1. 11.1.1 Commitments
      2. 11.1.2 Sauber arbeiten​
      3. 11.1.3 Verhalten in der Krise​
    2. 11.2 Umgang mit Druck
      1. 11.2.1 Keine Panik​
      2. 11.2.2 Kommunizieren​ Sie
      3. 11.2.3 Verlassen Sie sich auf Ihre Disziplinen
      4. 11.2.4 Hilfe holen​
    3. 11.3 Schlussfolgerung
  19. Kapitel 12: Teamwork​
    1. 12.1 Programmierer kontra Menschen​
      1. 12.1.1 Programmierer kontra Arbeitgeber​
      2. 12.1.2 Programmierer kontra Programmierer​
    2. 12.2 Kleinhirne
    3. 12.3 Schlussfolgerung
  20. Kapitel 13: Teams und Projekte
    1. 13.1 Harmoniert es?
      1. 13.1.1 Das zusammengeschweißte Team​
      2. 13.1.2 Aber wie managt​ man so etwas?
      3. 13.1.3 Das Dilemma des Product Owner​
    2. 13.2 Schlussfolgerung
    3. 13.3 Bibliografie
  21. Kapitel 14: Mentoring, Lehrzeiten und die Handwerkskunst
    1. 14.1 Der Grad des Versagens​
    2. 14.2 Mentoring​
      1. 14.2.1 Digi-Comp I – Mein erster Computer
      2. 14.2.2 Die ECP-18 in der Highschool
      3. 14.2.3 Unkonventionelles Mentoring​
      4. 14.2.4 Schicksalsschläge​
    3. 14.3 Die Lehrzeit​
      1. 14.3.1 Die Lehrzeit bei der Software
      2. 14.3.2 Die Realität
    4. 14.4 Die Handwerkskunst​
      1. 14.4.1 Menschen überzeugen
    5. 14.5 Schlussfolgerung
  22. Anhang A: Werkzeuge und Hilfsmittel
    1. A.1 Tools​
    2. A.2 Quellcodekontrolle​
      1. A.2.1 Ein »Enterprise«-System der Quellcodekontrolle
      2. A.2.2 Pessimistisches​ kontra optimistisches Locking​
      3. A.2.3 CVS​/SVN​
      4. A.2.4 git
    3. A.3 IDE/Editor​
      1. A.3.1 vi​
      2. A.3.2 Emacs​
      3. A.3.3 Eclipse​/IntelliJ​
      4. A.3.4 TextMate​
    4. A.4 Issue-Tracking-System​e
      1. A.4.1 Bug-Zähler​
    5. A.5 Continuous Build​
    6. A.6 Tools für Unit-Test​s​
    7. A.7 Tools für Komponententest​s​
      1. A.7.1 Die »Definition of Done«
      2. A.7.2 FitNesse​
      3. A.7.3 Andere Tools
    8. A.8 Tool​s für Integrationstest​s
    9. A.9 UML​/MDA​
      1. A.9.1 Die Details​
      2. A.9.2 Keine Hoffnung, keine Änderung
    10. A.10 Schlussfolgerung