Software-Entwicklung in der realen Welt

Kapitel 1. Beginn der Reise

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

In diesem Kapitel geben wir dir eine Einführung in die Konzepte und Prinzipien dieses Buches. Eine gute Art, den Gesamtansatz zusammenzufassen, ist " Practices and Principles over Technology". Es gibt bereits viele Bücher über bestimmte Technologien, und wir wollen diesem riesigen Haufen nicht noch mehr hinzufügen. Das soll nicht heißen, dass das Detailwissen über eine bestimmte Sprache, ein bestimmtes Framework oder eine bestimmte Bibliothek nicht nützlich ist. Es ist nur kürzer haltbar als allgemeine Praktiken und Prinzipien, die über einen längeren Zeitraum und über verschiedene Sprachen und Frameworks hinweg gelten. Genau dabei kann dir dieses Buch helfen.

Themen

Im gesamten Buch haben wir eine projektbasierte Struktur verwendet, um das Lernen zu erleichtern. Es lohnt sich, über die verschiedenen Themen nachzudenken, die sich durch die Kapitel ziehen, wie sie miteinander verbunden sind und warum wir sie ausgewählt haben. Im Folgenden findest du die vier verschiedenen Themen, die sich durch die Kapitel ziehen.

Java-Funktionen

Die Strukturierung von Code mit Klassen und Schnittstellen wird in Kapitel 2 behandelt. In Kapitel 3 gehen wir auf Ausnahmen und Pakete ein. Außerdem bekommst du in Kapitel 3 einen kurzen Überblick über Lambda-Ausdrücke. Dann werden in Kapitel 5 lokale Variablentypen und Switch-Ausdrücke erklärt, und schließlich werden in Kapitel 7 Lambda-Ausdrücke und Methodenreferenzen im Detail behandelt. Die Java-Sprachfunktionen sind wichtig, weil so viele Softwareprojekte in Java geschrieben werden, dass es nützlich ist, die Funktionsweise der Sprache zu kennen. Viele dieser Funktionen sind auch in anderen Programmiersprachen nützlich, z. B. in C#, C++, Ruby oder Python. Auch wenn diese Sprachen Unterschiede aufweisen, ist das Wissen über die Verwendung von Klassen und grundlegenden OOP-Konzepten in allen Sprachen nützlich.

Software Design und Architektur

Im Laufe des Buches werden eine Reihe von Entwurfsmustern vorgestellt, die dir helfen, gemeinsame Lösungen für häufige Probleme zu finden, denen Entwickler/innen begegnen. Diese Muster sind wichtig zu kennen, denn auch wenn es so aussieht, als ob jedes Softwareprojekt anders ist und seine eigenen Probleme mit sich bringt, sind viele von ihnen in der Praxis schon einmal aufgetreten. Wenn du häufige Probleme und Lösungen kennst, die bereits von Entwicklern gelöst wurden, musst du bei einem neuen Softwareprojekt das Rad nicht neu erfinden und kannst deine Software schneller und zuverlässiger liefern.

Die übergeordneten Konzepte der Kopplung und Kohäsion werden zu Beginn des Buches in Kapitel 2 vorgestellt. Das Benachrichtigungsmuster wird in Kapitel 3 vorgestellt. Wie man eine benutzerfreundliche Fluent API entwirft und das Builder-Muster werden in Kapitel 5 vorgestellt. In Kapitel 6 geht es um die großen Konzepte der ereignisgesteuerten und hexagonalen Architekturen und in Kapitel 7 um das Repository-Muster. Schließlich wirst du in Kapitel 7 auch in die funktionale Programmierung eingeführt.

SOLID

Wir behandeln alle SOLID-Prinzipien in verschiedenen Kapiteln. Dabei handelt es sich um eine Reihe von Prinzipien, die dazu beitragen sollen, dass Software leichter zu warten ist. Auch wenn wir das Schreiben von Software gerne als den spaßigen Teil betrachten, muss sich die Software, die du schreibst, weiterentwickeln, wachsen und gewartet werden, wenn sie erfolgreich sein soll. Der Versuch, die Software so wartungsfreundlich wie möglich zu gestalten, hilft bei dieser Entwicklung, der Wartung und der langfristigen Erweiterung von Funktionen. Die SOLID-Prinzipien und die Kapitel, in denen wir sie besprechen werden, sind:

• Das Prinzip der einzigen Verantwortung (SRP), das in Kapitel 2 behandelt wird

• Offenes/Geschlossenes Prinzip (OCP), besprochen in Kapitel 3

• Liskov-Substitutionsprinzip (LSP), behandelt in Kapitel 4

• Prinzip der Schnittstellentrennung (ISP), behandelt in Kapitel 5

• Das Prinzip der Umkehrung von Abhängigkeiten (DIP), das in Kapitel 7 behandelt wird

Testen

Es ist sehr wichtig, zuverlässigen Code zu schreiben, der im Laufe der Zeit leicht weiterentwickelt werden kann. Automatisierte Tests sind der Schlüssel dazu. Je größer die Software wird, die du schreibst, desto schwieriger wird es, verschiedene mögliche Fälle manuell zu testen. Du musst deine Testprozesse automatisieren, um die tagelange menschliche Arbeit zu vermeiden, die du sonst für das Testen deiner Software benötigen würdest.

In den Kapiteln 2 und4 lernst du die Grundlagen des Schreibens von Tests kennen. In Kapitel 5 wird dies auf die testgetriebene Entwicklung (TDD) ausgeweitet. In Kapitel 6 behandeln wir die Verwendung von Testdoubles, einschließlich Mocks und Stubs.

Kapitel Zusammenfassung

Hier ist die Gliederung der Kapitel.

Kapitel 2, Der Kontoauszugsanalyzer

Du schreibst ein Programm zur Analyse von Kontoauszügen, um Menschen zu helfen, ihre Finanzen besser zu verstehen. So lernst du mehr über die wichtigsten objektorientierten Entwurfstechniken wie das Single Responsibility Principle (SRP), Kopplung und Kohäsion.

Kapitel 3, Erweitern des Bank Statements Analyzer

In diesem Kapitel lernst du, wie du den Code aus Kapitel 2 erweiterst, indem du weitere Funktionen hinzufügst, das Strategy Design Pattern und das Open/Closed-Prinzip verwendest und wie du Fehler mithilfe von Exceptions modellierst.

Kapitel 4, Das Dokumentenmanagementsystem

In diesem Kapitel helfen wir einer erfolgreichen Ärztin, ihre Patientenakten besser zu verwalten. Dabei werden Konzepte wie Vererbung im Softwaredesign, das Liskov-Substitutionsprinzip und Kompromisse zwischen Komposition und Vererbung vorgestellt. Außerdem lernst du, wie du mit automatisiertem Testcode zuverlässigere Software schreiben kannst.

Kapitel 5, Die Business Rules Engine

Du erfährst, wie du eine Core Business Rules Engine aufbaust - eine Methode zur Definition von Geschäftslogik, die flexibel und einfach zu warten ist. In diesem Kapitel werden die Themen testgetriebene Entwicklung, Entwicklung einer Fluent API und das Prinzip der Schnittstellentrennung vorgestellt.

Kapitel 6, Twootr

Twootr ist eine Messaging-Plattform, die es Menschen ermöglicht, Kurznachrichten an andere Nutzer zu senden, die ihnen folgen. In diesem Kapitel wird der Kern eines einfachen Twootr-Systems entwickelt. Du lernst, wie du von außen nach innen denkst - von den Anforderungen bis hin zum Kern deiner Anwendung. Außerdem lernst du, wie du Testdoubles verwendest, um die Interaktionen zwischen den verschiedenen Komponenten deiner Codebasis zu isolieren und zu testen.

Kapitel 7, Ausweitung von Twootr

Das letzte projektbasierte Kapitel des Buches erweitert die Twootr-Implementierung aus dem vorherigen Kapitel. Es erklärt das Dependency Inversion Principle und stellt übergreifende Architekturen wie ereignisgesteuerte und hexagonale Architekturen vor. Dieses Kapitel kann dir helfen, dein Wissen über automatisiertes Testen zu erweitern, indem es Testdoubles wie Stubs und Mocks sowie funktionale Programmiertechniken behandelt.

Kapitel 8, Schlussfolgerung

Das abschließende Kapitel greift die wichtigsten Themen und Konzepte des Buches auf und bietet zusätzliche Ressourcen für deine weitere Programmierkarriere.

Iteration an dir

Als Softwareentwickler gehst du vielleicht iterativ an Projekte heran, d.h. du schneidest die Aufgaben mit der höchsten Priorität für ein oder zwei Wochen ab, setzt sie um und entscheidest dann anhand des Feedbacks über die nächsten Aufgaben. Wir haben festgestellt, dass es sich oft lohnt, den Fortschritt deiner eigenen Fähigkeiten auf dieselbe Weise zu bewerten.

Am Ende jedes Kapitels gibt es einen kurzen Abschnitt "Iterating on You" mit einigen Vorschlägen, wie du das Gelernte aus dem Kapitel in deiner eigenen Zeit verbessern kannst.

Jetzt, wo du weißt, was du von diesem Buch erwarten kannst, können wir uns an die Arbeit machen!