Die besten Bücher für Programmierer
(aktualisiert 2024)
25. Mai 2023In diesem Artikel habe ich eine Liste der besten Software-Engineering-Bücher zusammengestellt.
Die Liste enthält Bücher über Softwaredesign, objektorientiertes Design, Softwareentwicklung und Softwaretests.
Hier geht es zu Büchern über Java im Speziellen.
Falls du etwas entspannderes suchst, findest du hier einige Romane für Nerds.
Bücher für Softwareentwickler eignen sich selten als Hörbücher, da sie oft Code-Beispiele und komplexe Diagramme enthalten. Glücklicherweise gibt es einige Ausnahmen. Ich gebe daher zu jedem Buch auch an, ob es als Hörbuch geeignet und verfügbar ist.
Der pragmatische Programmierer: Ihr Weg zur Meisterschaft
von Andrew Hunt und David Thomas
Englishes Original: The Pragmatic Programmer. From Journeyman to Master: From Journeyman to Master
Dieses Buch enthält geballte, praktische Erfahrung aus mehreren Jahrzehnten Programmierpraxis. Es beschreibt die besten Praktiken und die größten Fallstricke vieler Aspekte der Softwareentwicklung anschaulich und mit zahlreichen Praxisbeispielen. Dabei liegt der Fokus auf der Erstellung von hochqualitativen, d. h. funktionierendem, flexiblem, wiederverwendbarem und wartbarem Code.
Das Buch ist sowohl für Anfänger als auch für fortgeschrittene Programmierer geeignet.
Anfänger finden in diesem Buch wertvolles Wissen, für das sie sonst Jahre oder Jahrzehnte bräuchten, um es durch eigene Erfahrung aufzubauen (wobei das Buch diese Erfahrung natürlich nicht ersetzen kann).
Forgeschrittene können in diesem Buch ihre eigene Erfahrung in strukturierter Form wiederfinden, sie festigen und vertiefen – und sicher noch den ein oder anderen zusätzlichen Tipp mitnehmen.
Neben zahlreichen Anekdoten und Analogien enthält jeder Abschnitt praktische Übungsaufgaben mit Lösungen am Ende des Buches. Ein Buch, das jeder Programmierer gelesen haben sollte.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele und Übungsaufgaben.
Clean Code - Refactoring, Patterns, Testen und Techniken für sauberen Code
von Robert C. Martin
Englisches Original: Clean Code: A Handbook of Agile Software Craftsmanship
In diesem Klassiker der Softwareentwicklungs-Bücher geht es, wie der Name schon sagt, um sauberen Code: Code, der nicht nur funktioniert, sondern vor allem gut lesbar und wartbar ist.
Dazu gehören u. a.
- aussagekräftige Namen,
- kurze Funktionen, die eine (und nur eine) Aufgabe auf einer einheitlichen Abstraktionsebene ausführen,
- aussagekräftige (oder gar keine) Kommentare (im Gegensatz zu solchen, die bloß wiederholen, was der Code tut, oder – schlimmer noch – was er früher einmal getan hat),
- ein konsistenter Code-Stil,
- eine saubere Klassenstruktur (dieser Punkt wird ausführlicher behandelt im zuvor vorgestellten "Agile Software Development: Principles, Patterns, and Practices")
- eine Fehlerbehandlung, die die eigentliche Businesslogik nicht verschleiert,
- Unit-Tests, optimalerweise testgetrieben entstanden.
Die vorgestellten Prinzipien werden anhand mehrerer konkreter Java-Fallstudien erläutert.
Das Buch ist einfach zu verstehen und durch eingestreute Anekdoten unterhaltsam zu lesen. Jeder Entwickler sollte dieses Buch lesen und sich die vorgestellten Prinzipien in Fleisch und Blut übergehen lassen.
Das Kapitel über Concurrency ist leider stark vereinfacht darstellt (ohne auf diese Tatsache hinzuweisen). Moderne Optimierungen wie Instruction Reordering und CPU-Cache-Effekte, werden nicht angesprochen. So kann sich der Leser nach Lektüre dieses Kapitels schnell in trügerischer Sicherheit wähnen und subtile Bugs produzieren, die im Nachhinein nur sehr schwer zu finden sind.
Um Sicherheit im Umgang mit Concurrency zu gewinnen, lege ich jedem Java-Entwickler Brian Goetz' "Java Concurrency in Practice" ans Herz.
Zum Schluss noch ein persönlicher Tipp zum Thema Code Style: Erfindet keinen eigenen Style. Erspart euch die zahllosen Diskussionen im Team und nehmt stattdessen einen existierenden, möglichst weit verbreiteten Stil, für den es Dokumentation, Checker, Formatierer und IDE-Plugins gibt. Ein gutes Beispiel ist Google’s Java Style Guide und die zugehörigen Tools.
Geeignet als Hörbuch? Nein! Auch wenn es dieses Buch unerklärlicherweise als Hörbuch gibt, ist es aufgrund der zahlreichen Code-Beispiele nicht als solches geeignet.
Design Patterns: Entwurfsmuster als Elemente wiederverwendbarer objektorientierter Software
von Erich Gamma, Richard Helm, Ralph E. Johnson, John Vlissides
Englishes Original: Design Patterns: Elements of Reusable Object-Oriented Software
Diesen Klassiker sollte eigentlich jeder Programmierer gelesen haben. „Eigentlich“, weil es sehr akademisch geschrieben und daher schwer zu lesen ist – insbesondere wenn man es als nicht Muttersprachler in der Originalausgabe liest.
Es beschreibt einige der wichtigsten Entwurfsmuster (wenn nicht die wichtigsten überhaupt) und ihre Beziehungen zueinander sehr detailliert.
Man merkt, dass das Buch schon 25 Jahre alt ist: die Codebeispiele sind aus heutiger Sicht teilweise veraltet und moderne Aspekte wie Concurrency werden komplett ignoriert. Dennoch sollte jeder Programmierer dieses Werk im Bücherregal haben und die klassischen 23 Entwurfsmuster kennen, erkennen und anwenden können.
Wer es etwas praktischer mag, dem kann ich den Online-Kurs „Java Design Patterns“ von Dr. Heinz Kabutz, dem Autor des bekannten JavaSpecialists‘ Newsletters, empfehlen.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele und Diagramme.
Clean Architecture - Gute Softwarearchitekturen: Das Praxis-Handbuch für professionelles Softwaredesign. Regeln und Paradigmen für effiziente Softwarestrukturierung.
von Robert C. Martin
Englisches Original: Clean Architecture: A Craftsman's Guide to Software Structure and Design: A Craftsman's Guide to Software Structure and Design
Eine gute Architektur zeichnet sich laut Uncle Bob dadurch aus, dass Software mit minimalem Aufwand an neue und sich ändernde Anforderungen angepasst werden kann – und damit eine lange und profitable Lebensdauer hat.
Zunächst gibt das Buch eine Einführung in die Grundprinzipien des Software-Designs (SOLID-Prinzipien), Prinzipien des Komponentendesigns (Kohäsion und Kopplung) und Metriken zur Bewertung des Designs (Efferente und Afferente Kopplung, Instabilität, Abstraktheit). Alle Prinzipien und Metriken hat Uncle Bob bereits 2002 in “Agile Software Development: Principles, Patterns, and Practices” beschrieben; größtenteils wurden vollständige Abschnitte einfach übernommen.
Der Schwerpunkt des Buchs liegt auf der Herleitung und Beschreibung der von Uncle Bob so bezeichneten “Clean Architecture”:
Im Kern der Software stehen die fachlichen Komponenten, wie Entitäten und Anwendungsfälle. Diese werden klar abgegrenzt von sogenannten "sekundären Komponenten" – technischen Implementierungsdetails wie Datenbanken, Benutzeroberflächen oder Frameworks. Alle Abhängigkeiten fließen von den technischen Details zum Kern. Erreicht wird dies durch Dependency Inversion an den Komponentengrenzen.
Die Entkopplung erleichtert das Testen von Komponenten. Technologieentscheidungen (z. B. welche Persistenztechnologie oder welches Dependency Injection Framework verwendet werden soll) können aufgeschoben – oder später im Projekt relativ einfach revidiert werden.
Zahlreiche Praxisbeispiele helfen beim Verständnis der Theorie. Und wie alle Bücher von Uncle Bob ist auch dieses mit zahlreichen Anekdoten aus dem Berufsleben des Autors – bis zurück in die 1970er-Jahre – gespickt. Diese Anekdoten sind nicht nur unterhaltsam, sondern helfen auch, den langen evolutionären Weg zur modernen Softwarearchitektur zu verstehen.
Alle Softwarearchitektinnen und -architekten, Programmiererinnen und Programmierer sollten “Clean Architecture” gelesen haben – nicht nur, um moderne Softwarearchitekturen zu implementieren – sondern auch die theoretischen Grundlagen dahinter zu verstehen.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Diagramme und Codebeispiele.
Du findest übrigens eine Tutorial-Serie über hexagonale Architektur (die fast identisch ist mit Clean Architecture) im Software-Craftsmanship-Bereich dieser Webseite.
Refactoring: Wie Sie das Design bestehender Software verbessern
von Martin Fowler
Englisches Original: Refactoring: Improving the Design of Existing Code
Mit diesem Klassiker der Softwareentwicklung hat Martin Fowler 1999 das Thema "Refactoring", das damals schon in der SmallTalk-Community bekannt war, einer breiten Entwicklergemeinde vorgestellt.
Das Buch beschreibt zunächst die grundlegenden Prinzipien des Refactorings und stellt diese an einem einführenden Beispiel anschaulich dar.
Anlass für ein Refactoring ist in der Regel ein "Code Smell", also Code, der zwar funktioniert, aber schwer zu lesen und zu warten ist. Durch die Benennung und Beschreibung weit verbreiteter Code Smells hat Fowler auch diese der Entwicklergemeinde bekannt gemacht.
Der größte Teil des Buches besteht aus einem Katalog von über 60 Refactorings. Für jedes Refactoring beschreibt der Autor die Motivation (d.h. die Situation, in der es anzuwenden ist), erklärt die Funktionalität Schritt für Schritt und demonstriert sie anschaulich anhand von Code-Beispielen in JavaScript.
Hier werden die Änderungen der zweiten Ausgabe deutlich: Fowler hat das Buch nicht bloß oberflächlich aufpoliert, sondern den gesamten Katalog umfangreich aktualisiert. So hat er Refactorings umbenannt, konsolidiert, hinzugefügt und die Java-Beispiele durch JavaScript-Varianten ersetzt. Wenn sich Unterschiede durch die Verwendung von schwach bzw. stark typisierten Programmiersprachen ergeben, gibt er entsprechende Hinweise.
"Refactoring" ist keine leichte Kost (bei den fortgeschrittenen Refactorings musste ich immer wieder eine Pause einlegen) – dennoch halte ich es für eine zeitlose Pflichtlektüre für alle Softwareentwickler.
Für Anfänger ist es ein hervorragender Einstieg in das Thema. Und Profis, für die Refactoring seit Jahren zum TDD-Zyklus gehört und die jeden Refactoring-Shortcut ihrer IDE auswendig kennen, werden das ein oder andere neue Refactoring kennenlernen – bzw. feststellen, dass Refactorings, die sie intuitiv durchgeführt haben, auch einen Namen und einen formalen Prozess haben.
Geeignet als Hörbuch: Nein, und zum Glück ist es auch nicht als solches erhältlich.
Domain-Driven Design: Tackling Complexity in the Heart of Software
von Eric Evans
Eric Evans beschreibt in seinem Klassiker einen bahnbrechenden Ansatz der Softwareentwicklung, dessen Kernelement ein objektorientiertes Modell ist, welches das fachliche – also das in den Geschäftsabteilungen eines Unternehmens verwendete – in der Regel nicht formell definierte – Modell möglichst originalgetreu abbildet.
Die Entwicklung und Pflege eines solchen Modells erfordert eine enge Zusammenarbeit zwischen IT- und Fachabteilungen. Die Schaffung einer gemeinsamen, eindeutigen Sprache – der “ubiquitous language” – ermöglicht eine Kommunikation ohne Mehrdeutigkeiten und Missverständnisse.
Domänenmodell und enge Zusammenarbeit führen letztendlich zu einer Anwendung, die genau das tut, was sich die Fachabteilung von ihr erhofft hat – und die sich leicht an neue Anforderungen anpassen lässt.
Das Buch zeigt – unterstützt durch zahlreiche anschauliche Beispiele – einen systematischen Weg von den fachlichen Anforderungen hin zum detaillierten technischen Modell. Es bedient sich dabei eines Repertoires technischer Bausteinen – wie Entities, Value Objects, Aggregates, Services, Repositories und Factories – sowie übergeordneter Konzepten wie Bounded Context und Context Map, Shared Kernel und Anticorruption Layer sowie Core- und Subdomains, um nur die bekanntesten zu nennen.
Das Buch ist eines der wichtigsten in der Softwareentwicklung und auch nach zwei Jahrzehnten noch topaktuell. Es ist allerdings keine leichte Lektüre – idealerweise sollte man einige Jahre an Programmiererfahrung mitbringen und sich für das Durcharbeiten ein paar Wochen Zeit nehmen. Die investierte Zeit und Mühe werden sich lohnen und dich auf eine neue Ebene der Softwareentwicklung heben.
Geeignet als Hörbuch: Nein.
Implementing Domain-Driven Design
von Vaughn Vernon
In „Implementing Domain-Driven Design” nimmt Vaughn Vernon den Leser mit auf die Reise eines fiktiven Entwicklerteams, das ein Softwareprojekt mittels Domain-Driven Designs in die Praxis umsetzt. Dabei behandelt er neben strategischem Design (Domains, Subdomains, Bounded Contexts, Context Maps) und taktischem Design (Entities, Value Objects, Services, Modules, Aggregates, Factories, Repositories) auch Softwarearchitekturen, die sich gut mit Domain-Driven Design kombinieren lassen (wie Hexagonale Architektur, CQRS, Event-Driven Architecture, Event Sourcing).
Wie im richtigen Leben machen die Entwickler Fehler und lernen aus ihnen. Dies hilft dem Leser an vielen Stellen zu verstehen, warum sich der anfängliche Mehraufwand für Domain-Driven Design auf lange Sicht auszahlt.
Das Buch ist eine großartige Ergänzung zu Evans’ Klassiker „Domain-Driven Design” und hat mir insbesondere dabei geholfen, den Zusammenhang von Bounded Contexts, Core Domain, Supporting Subdomains und generischen Subdomains zu verstehen. (Wichtig ist zu erwähnen, dass man Evans’ Buch nicht gelesen haben muss – alle Konzepte werden auch in diesem Buch von Grund auf erklärt.)
Die Prinzipien werden anhand von praxisnahen, detaillierten und leicht verständlichen Beispielen erläutert, die in Java (und teilweise Spring) implementiert sind. Ich verwende dieses Buch (zusammen mit Get Your Hands Dirty on Clean Architecture) regelmäßig als Nachschlagewerk.
Genau wie bei Evans’ Klassiker sollte man sich ausreichend Zeit nehmen, um das Buch gründlich durchzuarbeiten. Ich empfehle es allen, die Domain-Driven Design erfolgreich in der Praxis einsetzen wollen.
Geeignet als Hörbuch: Nein.
Domain-Driven Design kompakt
von Vaughn Vernon
Englisches Original: Domain-Driven Design Distilled
Vaughn Vernon liefert mit „Domain-Driven Design kompakt“ eine kompakte Zusammenfassung seines Bestsellers „Implementing Domain-Driven Design“ (im Folgenden: IDDD).
Das Buch erklärt auf kurzen 158 Seiten in stark komprimierter Form die wesentlichen Konzepte von DDD: Bounded Contexts, Ubiquitous Language, Subdomains, Entities, Value Objects, Aggregates und Events.
Als Bonus enthält es eine detaillierte Beschreibung der Modellierungstechnik „Event Storming” (die in IDDD nicht behandelt wird).
Das Buch eignet sich zum schnellen Erlernen der grundlegenden Konzepte von Domain-Driven Design. Ich empfehle es als Einstieg und zur Etablierung eines gemeinsamen Vokabulars für Domänenexperten und Manager.
Für Softwareentwickler, die DDD in der Praxis umsetzen wollen, ist das Buch nicht tiefgründig genug; daher würde ich Entwicklern eher zu „Implementing Domain-Driven Design“ oder Evans’ Klassiker „Domain-Driven Design“ raten und dieses Buch einige Monate später als Auffrischung zu lesen.
Geeignet als Hörbuch: Nein.
Get Your Hands Dirty on Clean Architecture: A hands-on guide to creating clean web applications with code examples in Java
von Tom Hombergs
Was ist hexagonale Architektur? Was sind ihre Vorteile? Und wie implementiert man eine hexagonale Anwendung in Java? Diese Fragen beantwortet Tom Hombergs in “Get Your Hands Dirty on Clean Architecture”.
Der Autor beschreibt zunächst die Probleme der klassischen Schichtenarchitektur und erklärt, wie die von Robert C. Martin beschriebene “Clean Architecture” und die von Alistair Cockburn eingeführte (prinzipiell vergleichbare) “Hexagonale Architektur” die Anforderungen einer modernen Anwendung (Wartbarkeit, Anpassbarkeit, Erweiterbarkeit) besser erfüllen können – nämlich indem sie die fachliche Domäne (und nicht technische Details) in den Mittelpunkt der Architektur stellen.
Nach kurzer Theorie folgt die Praxis: Schritt für Schritt entwickelt der Autor eine beispielhafte Java-Anwendung mit Entities, Use Cases, Ports und Adaptern. Für die Adapter stellt er verschiedene Mapping-Strategien vor und bespricht deren Vor- und Nachteile.
Er geht detailliert auf den Schnitt und die Testbarkeit der Komponenten ein und schlägt eine Paketstruktur vor, die den Architekturstil sichtbar macht.
Nachdem alle Komponenten der Anwendung fertiggestellt sind, zeigt der Autor, wie diese – zum einen mit reinem Java und zum anderen mit dem Spring Framework – zusammengesetzt werden können. Damit demonstriert er eindrucksvoll, dass auch die Umsetzung der Dependency Injection bloß ein austauschbares Detail der Software sein kann.
Anschließend zeigt der Autor, wie die Anwendung mit separaten Build-Artefakten, z. B. Maven-Modulen, so modularisiert werden kann, dass der Architekturstil nicht ohne weiteres umgangen werden kann. Leider geht der Autor nicht darauf ein, inwieweit das Java-Modulsystem diese Aufgabe ebenfalls übernehmen könnte.
Schließlich erörtert er noch, welche Abkürzungen wir beim Mapping zwischen den Schichten einschlagen können und welchen technischen Schulden wir uns dabei bewusst sein müssen.
Das Buch ist hervorragend strukturiert und durchgehend verständlich und präzise formuliert. Dem Autor ist es gelungen, auf nur 138 Seiten unterzubringen, was in "Designing Hexagonal Architecture with Java" (ein Buch, das ich nicht empfehle und das ich deshalb hier auch nicht aufliste) mehr als den vierfachen Platz einnimmt. Eine hervorragende Leistung!
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Diagramme und Codebeispiele.
Du findest übrigens eine Tutorial-Serie über hexagonale Architektur im Software-Craftsmanship-Bereich dieser Webseite.
Effektives Arbeiten mit Legacy Code. Refactoring und Testen bestehender Software
von Michael C. Feathers
Englisches Original: Working Effectively With Legacy Code
Dass Tests wichtig sind, und dass Test-Driven-Development zu gut getesteter, gut strukturierter Software führt, weiß heutzutage jeder Programmierer. Leider war das nicht immer der Fall. Und so stehen wir oft vor der Herausforderung, ein System ohne Tests – ein also ein “Legacy System” nach Michael Feathers Definition – weiterzuentwickeln.
Doch wie gehen wir vor, wenn wir keine Testabdeckung haben, um sicherzustellen, dass unsere Änderungen nichts kaputt machen? Und wenn wir andererseits diese Tests nicht schreiben können, weil der Code zu komplex ist, viel zu viele Abhängigkeiten enthält und Logik und Präsentation miteinander verwoben sind?
Was können wir tun, wenn wir die zu testende Klasse nicht instanziieren können, weil wir ihrem Konstruktor ein Objekt übergeben müssen, das wir nicht einfach erzeugen können? Oder wenn die zu testende Methode auf die Datenbank zugreift – obwohl dieser Datenbankzugriff für die Funktionalität, die wir testen wollen, nicht notwendig ist?
Dieses Buch enthält einen Katalog von Mechanismen, um diese Abhängigkeiten zu lokalisieren und aufzubrechen. Und um den Code entsprechend zu modularisieren, wobei Modulgrenzen geschaffen werden – sogenannte “Seams” (deutsch: “Nähte”), an denen wir mit unseren Unit-Tests ansetzen können.
Die vorgestellten Strategien erlauben Änderungen mit minimalen Risiken. Die Refactoring-Features moderner IDEs erlauben es viele dieser Änderungen vollautomatisch durchzuführen. Änderungen, die es dann erlauben erste Tests zu implementieren, um darauf aufbauend weitreichendere Refactorings durchzuführen, die letztendlich die Codebasis in ein besseres Design überführen.
Der Autor erklärt alle Strategien anhand hervorragender, praxisnaher Beispiele, die hauptsächlich in Java und C++ geschrieben sind.
Leider wurde das Buch seit 15 Jahren nicht aktualisiert. Vor allem unerfahrene Programmierer sollten darauf achten, nicht jede Strategie dogmatisch umzusetzen. Für einige Mechanismen gibt es heutzutage bessere Alternativen; einige der Praktiken führen zu schlechterem, statt zu besserem Code; und das Thema Threadsicherheit – ein Kernthema in den meisten heutigen Unternehmensanwendungen – wird völlig außer Acht gelassen.
Beispielsweise braucht man heutzutage nicht mehr für jede zu mockende Klasse ein Interface. Mockito kann problemlos Klassen mocken, also Abhängigkeiten auflösen ohne ein Interface zu extrahieren. Und wer doch ein Interface extrahiert, beachte dabei bitte das Interface Segregation Principle! Die Aussage des Autors, "it's nice to have an interface that covers all of the public methods of a class" (S. 366), steht leider in krassem Widerspruch dazu.
Den Aufruf abstrakter Methoden aus einem Konstruktor heraus ("Extract and override factory method") sollte man besser vermeiden, wenn man nicht plötzlich einem nur teilweise initialisierten Objekt gegenüberstehen möchte. Aus gutem Grund verbietet C++ diese Praktik. Fünfundfünfzig Seiten nach der Einführung dieser Strategie rät der Autor schließlich vor deren Einsatz auch in Java ab.
Multithreading ist in fast keinem der älteren Klassiker ein Thema. Heutzutage kommt kein Programmierer mehr daran vorbei. Wenn du eine Klasse mit Strategien wie "Break Out Method Object" extrahierst, solltest du daher unbedingt einen Hinweis anbringen, dass die Klasse nicht threadsicher ist. (Alternativ kannst du Instanzvariablen durch geeignete Lock-Mechanismen schützen.)
Trotz der genannten altersbedingten Schwächen kann ich das Buch jedem Programmierer empfehlen, der mit Legacy-Code arbeiten muss. Erfahrene Programmierer haben sicherlich die eine oder andere Strategie schon einmal intuitiv angewendet. Andere Techniken mögen neu sein. So oder so, die Formalisierung hilft, die Strategien zu festigen, und ihre Namen verbessern die Kommunikation im Team.
Behalte nur zwei Dinge im Hinterkopf: Das Buch ist 15 Jahre alt, und für jede Regel gibt es eine Ausnahme!
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.
Extreme Programming: Das Manifest
von Kent Beck und Cynthia Andres
Englisches Original: Extreme Programming Explained: Embrace Change
In diesem bahnbrechenden Klassiker von 1999 und 2005 (2. Auflage, komplett überarbeitet mit Erkenntnissen aus fünf Jahren) stellt Kent Beck das von ihm entwickelte “Extreme Programming” vor.
Was für heutige Softwareentwickler nach gesundem Menschenverstand klingt, war damals revolutionär und hat die Art und Weise, wie wir Software entwickeln, grundlegend verändert. XP hat dazu geführt, dass wir Software mit besserer Qualität, in kürzerer Zeit, zu geringeren Kosten und mit höherer Kundenzufriedenheit entwickeln als noch vor zwanzig Jahren.
Das Buch stellt die – aus damaliger Sicht radikalen – Grundwerte und Prinzipien von XP vor – sowie die Praktiken, mit denen diese Grundwerte und Prinzipien in die Tat umgesetzt werden. Dazu gehören User Stories und inkrementelles Design, testgetriebene Entwicklung, kontinuierliche Integration mit schnellen Builds und Feedback sowie Pair Programming.
Was in den Anfängen der agilen Softwareentwicklung ein inspirierendes Buch für alle Programmierer gewesen sein muss, ist auch heute noch interessant. Es ist ein Geschichtsbuch, das uns in eine Zeit versetzt, in der XP, der Ursprung der modernen agilen Methoden, geboren wurde.
Geeignet als Hörbuch? Es wäre als Hörbuch geeignet, ist als solches allerdings nicht verfügbar.
The Programmer’s Brain: What Every Programmer Needs to Know about Cognition
von Felienne Hermans
Felienne Herman, Professorin für Informatik an der Vrije Universiteit Amsterdam, erklärt in ihrem Buch „The Programmer’s Brain“, gestützt auf wissenschaftliche Erkenntnisse aus der Neurowissenschaft, wie das menschliche Gehirn bei komplexen Aufgaben wie dem Programmieren funktioniert, insbesondere beim Lesen, Verstehen und Schreiben von Code sowie beim Erlernen einer neuen Programmiersprache.
Sie beschreibt, wie Langzeitgedächtnis, Kurzzeitgedächtnis und Arbeitsgedächtnis zusammenarbeiten und welche Rolle dabei das sogenannte „Chunking“ spielt (der Prozess des Gruppierens kleiner Informationseinheiten zu größeren, z. B. von Buchstaben zu Wörtern).
Wir erfahren, warum komplexe Aufgaben wie das Arbeiten mit unbekanntem Code zu einer kognitiven Überlastung führen können, und entdecken konkrete, kognitionswissenschaftlich fundierte Techniken, die uns helfen können, die kognitive Belastung zu reduzieren – sowohl für uns selbst als auch für z. B. Kollegen, die wir in neue Bereiche einarbeiten.
Wir erfahren auch, warum „Clean Code“-Techniken wie aussagekräftige und konsistente Benennung, kurze Methoden und einheitliche Formatierung so effektiv sind.
Die Autorin verwendet leicht verständliche Sprache und zahlreiche praxisnahe Beispiele aus verschiedenen Programmiersprachen, um ihre Ausführungen zu veranschaulichen.
Ich empfehle dieses Buch Programmiererinnen und Programmierern aller Erfahrungsstufen, die ihren Umgang mit komplexen Herausforderungen verbessern möchten, insbesondere denen, die verstehen möchten, wie sie die kognitive Überlastung vermeiden können, die häufig durch komplexe Aufgaben verursacht wird.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.
Clean Coder: Verhaltensregeln für professionelle Programmierer
von Robert C. Martin
Englisches Original: The Clean Coder: A Code of Conduct for Professional Programmers
Ausnahme-Programmierer ist nicht gleichzusetzen mit Profi.
In "Clean Coder" beschreibt der Software-Experte Robert "Uncle Bob" Martin die Denk- und Verhaltensweisen, die abseits des Schreibens von Code notwendig sind, um ein professioneller Programmierer zu werden.
Er gibt sowohl Anfängern als auch fortgeschrittenen Programmierern zahlreiche praktische Ratschläge, wie zum Beispiel:
- Wie verhält man sich professionell unter Druck?
- Wie reagiert man, wenn der Chef verlangt, dass eine Aufgabe schneller erledigt wird, als man es für möglich hält?
- Wie kann man den Aufwand überhaupt verlässlich abschätzen?
- Welche Tests sollte man schreiben, und wann?
- Wie verhält man sich professionell gegenüber seinen Teamkollegen?
Man merkt, dass der Autor aus einem hart erarbeiteten Erfahrungsschatz schöpft. Dabei muss man keineswegs immer mit ihm übereinstimmen.
Ich denke zum Beispiel nicht, dass der Flow-Zustand mehr Nachteile als Vorteile hat. Ich komme durchaus auch beim Pair Programming in den Flow. Und es ist in Ordnung, allein im Flow eine Lösung zu finden und diese dann im Pair nachzuprogrammieren.
Das Buch enthält viele persönliche, unterhaltsame Anekdoten aus Bobs langer Karriere. Für jüngere Leser könnten die Geschichten aus den 60er und 70er Jahren, als man noch mit Lochkarten und Teleprintern arbeitete, allerdings etwas zu antiquiert sein ;)
Als Hörbuch geeignet? Ja! Dies ist eines der wenigen Programmierbücher über Praktiken jenseits des eigentlichen Codes. Du wirst in diesem Buch keine einzige Zeile Programmcode und kein einziges UML-Diagramm finden. Es ist daher absolut als Hörbuch geeignet.
Clean Agile: Die Essenz der agilen Softwareentwicklung
von Robert C. Martin
Englisches Original: Clean Agile: Back to Basics
Im Februar 2001 trafen sich 17 Programmierer – unter ihnen Robert C. Martin, alias Uncle Bob – um verschiedene leichtgewichtige Softwareentwicklungsprozesse (XP, Scrum und andere) auf einen gemeinsamen Nenner zu bringen. Heraus kam das inzwischen weltberühmte Agile Manifest.
Doch das, was viele heute als "agil" bezeichnen – mit seinem übermäßigen Fokus auf Prozessen, aber vernachlässigten technischen Praktiken – ist weit entfernt von dem, was die Schöpfer damals im Sinn hatten.
Die Mission diesen Buches ist es, die Fakten richtig zu stellen und einen Überblick über die ursprünglichen agilen Ansichten, Ideen, Werte und Prinzipien zu geben.
Uncle Bob schreibt – wie immer – locker und unterhaltsam und rundet die historischen Erzählungen mit zahlreichen persönlichen Anekdoten ab.
Eine klare Empfehlung für jeden Programmierer.
Als Hörbuch geeignet? Ja! Es gibt im ganzen Buch keine Zeile Code und nur zwei beispielhafte Diagramme: ein Velocity- und ein Burn-Down-Chart. Beides kann man schnell googeln.
Clean Craftsmanship: Best Practices, Standards und Ethik für die Softwareentwicklung
von Robert C. Martin
Englisches Original: Clean Craftsmanship: Disciplines, Standards, and Ethics
In seinem neuesten Buch erklärt uns Onkel Bob die grundlegenden Praktiken und Prinzipien des Software-Handwerks, die jeder professionelle Programmierer kennen und befolgen sollte.
Das Buch besteht aus drei Teilen:
Teil 1, “Disziplin”, beschreibt fünf Kerndisziplinen des Extreme Programming (XP): Testgetriebene Entwicklung (TDD), Refactoring, einfaches Design, Pair Programmierung und Akzeptanztests.
TDD nimmt fast die Hälfte des Buches ein. Onkel Bob lässt uns über seine Schulter blicken, während er testgetrieben mehrere Katas löst (auch als Videos verfügbar).
In Teil 2, "Standards", geht es darum, wie man kontinuierlich hohe Produktivität mit stabiler Qualität in Einklang bringt; es geht um Aufwandsschätzungen in Form von Wahrscheinlichkeitsverteilungen und um den Mut, Nein zu sagen, wenn der Chef uns seinen unrealistischen Zeitplan aufzwingen will.
In Teil 3, "Ethik", geht es um unsere Verantwortung gegenüber unseren Usern, unseren Kollegen und Managern, der Gesellschaft und – nicht zuletzt – uns selbst. Indem wir konsequent robusten und effektiven Code schreiben, wenden wir Schaden ab und schaffen Vertrauen in unsere Arbeit.
Wie alle Bücher von Onkel Bob ist auch dieses sehr zu empfehlen. Es ist leicht zu lesen und wird wie immer durch historische Hintergründe und viele persönliche Anekdoten des Autors aufgelockert (die sich allerdings in seinen Werken wiederholen).
Als Hörbuch geeignet? Das Buch ist derzeit nicht als Hörbuch erhältlich. Sollte sich dies ändern (andere Werke von Onkel Bob sind als Hörbücher erhältlich), würde ich aufgrund der zahlreichen Codebeispiele und Diagramme in Teil 1 (der immerhin zwei Drittel des Buches umfasst) davon abraten.
The Passionate Programmer - Der leidenschaftliche Programmierer: Wie Programmierer ihre berufliche Laufbahn erfolgreich gestalten
von Chad Fowler
Englisches Original: The Passionate Programmer: Creating a Remarkable Career in Software Development
Dieses Buch gibt Softwareentwicklern zahlreiche hilfreiche und praktische Tipps für beruflichen Erfolg und Karriereentwicklung.
Der Autor beschreibt, welche technischen Fähigkeiten du als Programmierer haben solltest, wie du dich technisch weiterentwickeln solltest, aber auch wie du deinen Karriereweg nicht dem Zufall überlässt, sondern deine persönliche Entwicklung selbst in die Hand nimmst, eigene Ziele verfolgst und motiviert bleibst diese zu realisieren.
Dazu geht er inbesondere darauf ein, wie du dich als Programmierer vermarktest und gibt zahlreiche kurze Handlungsempfehlungen.
Geeignet als Hörbuch? Ja, allerdings ist das Buch aktuell nicht als Hörbuch verfügbar.
Soft Skills: The Software Developer's Life Manual
von John Sonmez
In diesem Buch gibt Entwickler und Life Coach John Sonmez hilfreiche Tipps zum Aufbau von Soft Skills, die ein Entwickler haben sollte, und die zu einem zufriedenstellenderen Leben als professioneller Softwareentwickler führen.
Es geht um die Themen Karriereentwicklung, Eigenvermarktung, Lernen, Produktivität, Investmentstrategien und finanzielle Sicherheit, Fitness und mentale Gesundheit – alles aus der Perspektive eines Softwareentwicklers.
Wer zur Abwechslung gerne einmal ein Buch für Programmierer ohne Quellcode und Diagramme lesen möchte, dem kann ich dieses Buch empfehlen.
Geeignet als Hörbuch? Ja, absolut. Besonders gefällt mir, dass John Sonmez seine Bücher selbst liest und immer wieder ein paar Absätze einstreut, die nicht im Buch vorhanden sind, z. B. wenn es zu einem Thema Neues zu sagen gibt.
The Complete Software Developer’s Career Guide
von John Sonmez
Dieses Buch ist ein umfangreicher Ratgeber für eine erfolgreiche Karriere in der Softwareentwicklung.
Es beantwortet Fragen aus allen Stufen der Entwicklerkarriere: Wie starte ich meine Karriere? Wie bekomme ich eine Job? In welche Richtung kann und sollte ich mich spezialisieren? Wie gehe ich mit Vorgesetzten und Kollegen um? Wie verdiene ich mir eine Beförderung? Wie entwickle ich mich selbst weiter?
Das Buch ist einfach und unterhaltsam geschrieben, mit persönlichen Anekdoten angereichert und insgesamt sehr angenehm zu lesen.
Geeignet als Hörbuch? Ja, absolut. Besonders gefällt mir, dass John Sonmez seine Bücher selbst liest und immer wieder ein paar Absätze einstreut, die nicht im Buch vorhanden sind, z. B. wenn es zu einem Thema Neues zu sagen gibt.
Growing Object-Oriented Software, Guided by Tests
von Steve Freeman und Nat Pryce
Dieses Buch gibt eine praktische Einführung in Test-Driven Development (TDD) – insbesondere in objektorientierter Programmierung.
Die Autoren (von denen einer der Entwickler von jMock ist) erklären, wie Unit Tests und Mock-Objekte zu einem sauberen, objektorientierten Design mit zuverlässigem und wartbaren Code führen.
In einer Fallstudie entwerfen und implementieren sie dazu testgetrieben ein Auktionssystem in Java.
Ich empfehle dieses Buch insbesondere jedem Java-Programmierer. Wenn Du einmal erlebt hast, wie Tests zu eleganterem Design und Code führen, wirst Du nie wieder ohne entwickeln wollen.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.
Agile Software Development: Principles, Patterns, and Practices
von Robert C. Martin
In diesem exzellenten Buch erklärt Robert C. Martin, auch bekannt als "Uncle Bob", Mitautor des agilen Manifests, die Kernkonzepte agiler Softwareentwicklung, von Extreme Programming (XP) und von "Test-First Design" (den Vorläufer von Test-Driven Design).
Er zeigt, wie man durch agiles Design und die Anwendung der SOLID-Prinzipien sauberen, wartbaren, objekt-orientierten Code schreibt.
Er demonstriert diese Prinzipien und die Anwendung bekannter Entwurfsmuster anhand dreier in C++ und Java entwickelter Fallstudien. Ich empfehle jedem Programmierer diese Fallstudien intensiv zu studieren und selbst zu implementieren.
Das Buch ist von 2002 und mittlerweile in einer neueren Auflage von 2013 verfügbar, die ich allerdings noch nicht gelesen habe.
Geeignet als Hörbuch? Absolut nicht! Das Buch ist voll von Quellcode und UML-Diagrammen, die für das Verständnis dieses Buchs unerlässlich sind.
Pattern Hatching: Design Patterns Applied
von John Vlissides
Dieses Buch von einem der vier Autoren des Klassikers „Design Patterns“ gibt Einblicke in den Entwicklungsprozess und beschreibt die zehn größten Missverständnisse über Design Patterns.
Häufig verwendete Entwurfsmuster werden am praktischen Beispiel erläutert – im Gegensatz zu der sehr akademischen Herangehensweise im Klassiker. Es werden Variationen von etablierten Mustern vorgestellt, sowie zwei gänzlich neue Entwurfsmuster.
Man muss dieses Buch nicht unbedingt gelesen haben, doch für mich war es nach dem Durcharbeiten von „Design Patterns“ eine sehr angenehme und deutlich leichter verdauliche Lektüre.
Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele und Diagramme.