In diesem Modul werden wir uns mit den grundlegenden Prinzipien der Softwareentwicklung befassen und uns dabei auf die SOLID-Prinzipien konzentrieren. Sie werden erkunden, wie diese Prinzipien angewendet werden können, um eine sauberere, besser wartbare und skalierbare Softwarearchitektur zu erstellen. Wir werden auch Techniken zur effektiven Strukturierung von Modulen behandeln, um die Qualität des Codes zu verbessern.

In diesem Modul zeigen wir Ihnen, wie Sie große Codebasen effektiv lesen und verstehen können. Sie lernen Techniken, um effizient durch den Code zu navigieren und Bereiche zu identifizieren, in denen Code-Smells verbessert oder durch Refactoring übersichtlicher und wartbarer gemacht werden können.

In diesem Modul wird der Geruch von wiederholtem Switch-Code vorgestellt und seine negativen Auswirkungen auf die Lesbarkeit und Wartbarkeit von Code diskutiert. Sie lernen, wie Sie wiederholte Switch-Anweisungen erkennen und refactorieren können, um einen saubereren, besser wartbaren Code zu erhalten.

In diesem Modul werden wir uns mit dem Codegeruch der primitiven Besessenheit beschäftigen und uns darauf konzentrieren, wie die übermäßige Verwendung primitiver Datentypen Ihren Code verkomplizieren kann. Sie werden lernen, wie Sie diese durch domänenspezifische Objekte ersetzen und so die Abstraktion und Lesbarkeit verbessern können.

In diesem Modul werden wir uns mit ineffizienten Schleifenstrukturen, einem der häufigsten Code-Smells, befassen und ihre Auswirkungen auf Leistung und Lesbarkeit diskutieren. Wir stellen bewährte Verfahren für das Refactoring von Schleifen vor, um sie effizienter und leichter verständlich zu machen.

In diesem Modul befassen wir uns mit dem Code-Geruch langer Parameterlisten und damit, wie übermäßige Parameter Funktionssignaturen verkomplizieren können. Sie lernen Strategien zur Vereinfachung dieser Listen kennen, z. B. die Verwendung von Objekten oder Standardwerten, um die Lesbarkeit und Wartbarkeit zu verbessern.

In diesem Modul werden wir uns mit dem Geruch von doppeltem Code befassen und erklären, wie wiederholte Logik in der Codebasis zu Inkonsistenzen und höheren Wartungskosten führen kann. Sie lernen Techniken zum Refactoring und zur Beseitigung von Redundanzen kennen, um die Wartbarkeit Ihrer Software zu verbessern.

In diesem Modul werden wir untersuchen, wie uninformative Kommentare Ihren Code unübersichtlich machen und die Klarheit beeinträchtigen können. Sie lernen, wie Sie nützliche, prägnante Kommentare schreiben und die Lesbarkeit des Codes verbessern können, indem Sie Redundanzen beseitigen.

In diesem Modul werden wir uns mit dem Codegeruch der Schrotflintenchirurgie befassen, bei dem Änderungen in einem Teil des Systems Änderungen in mehreren Klassen erfordern. Sie lernen Strategien für das Refactoring kennen, um die Komplexität dieser verstreuten Änderungen zu reduzieren und die Wartbarkeit zu verbessern.

In diesem Modul werden wir das Problem alternativer Klassen mit inkonsistenten Schnittstellen erörtern, die zu Verwirrung und Benutzerfreundlichkeit führen können. Sie lernen, wie man Klassen refactoriert, um Schnittstellen zu vereinheitlichen und die Konsistenz des Codes zu verbessern.

In diesem Modul werden wir uns mit dem abgelehnten Code-Geruch der Vererbung befassen, der auftritt, wenn eine Unterklasse Funktionalität erbt, die sie nicht nutzt. Sie lernen, wie Sie Ihren Code refactorieren können, um den Missbrauch von Vererbung zu reduzieren und Komposition vorzuziehen, um Flexibilität und Wartbarkeit zu verbessern.

In diesem Modul werden wir uns mit dem Codegeruch von Datenklumpen befassen, bei dem zusammengehörige Daten in unangemessener Weise gruppiert sind. Sie lernen, wie Sie diese Datenstrukturen durch Refactoring besser organisieren und kapseln können, um die Wartbarkeit zu verbessern.

In diesem Modul werden wir den Geruch von Code aus der Mitte untersuchen, wo unnötige Klassen die Komplexität erhöhen, indem sie einfach Funktionen delegieren. Sie werden lernen, wie Sie Ihren Code durch Entfernen unnötiger Abstraktionsschichten refactorieren können, um Ihre Codebasis zu vereinfachen.

In diesem Modul befassen wir uns mit veränderlichen Daten und damit, wie unkontrollierte Änderungen des Zustands zu Fehlern und Inkonsistenzen führen können. Sie lernen, wie Sie Ihren Code refactorieren können, um die Unveränderlichkeit von Daten effektiv zu verwalten und so die Reliabilität und Vorhersagbarkeit zu verbessern.

In diesem Modul befassen wir uns mit dem Code-Geruch des Merkmals Neid, bei dem Methoden dazu neigen, sich zu stark auf Daten aus einer anderen Klasse zu konzentrieren. Sie lernen, wie Sie Ihren Code refactorieren können, um die Objektgrenzen zu verbessern und das Verhalten in die Klasse zu verlagern, in die es logischerweise gehört.

In diesem Modul werden wir uns mit dem Geruch von abweichendem Code befassen, bei dem ein Modul aus nicht zusammenhängenden Gründen häufig geändert werden muss. Sie lernen, wie Sie Ihren Code refactorieren können, um das Risiko zu minimieren, dass häufige Änderungen zu Instabilität oder Regressionen führen.

In diesem Modul befassen wir uns mit großen Schnittstellen und damit, wie sie die Wartung und Erweiterung von Code erschweren können. Sie lernen, wie Sie große Schnittstellen in kleinere, besser handhabbare Schnittstellen umwandeln können, die leichter zu pflegen und zu skalieren sind.

In diesem Modul werden wir uns mit dem Geruch von Multitasker Code beschäftigen, bei dem Klassen oder Methoden zu viele Verantwortlichkeiten übernehmen. Sie werden lernen, wie Sie das Single Responsibility Principle anwenden können, um Ihren Code zu refactorieren und seine Klarheit und Wartbarkeit zu verbessern.

In diesem Modul werden wir uns auf die Bedeutung klarer, intuitiver Namenskonventionen konzentrieren. Sie werden lernen, wie unklare Namen Verwirrung stiften können und wie Sie bewährte Verfahren für die Benennung von Variablen, Funktionen und Klassen anwenden können, um die Lesbarkeit zu verbessern.

In diesem Modul werden wir über spekulative Allgemeinheit sprechen und darüber, wie übermäßiges Engineering Code unnötig komplex machen kann. Sie werden lernen, wie Sie Code vereinfachen können, indem Sie verfrühte Abstraktionen entfernen und sich auf die aktuellen Anforderungen konzentrieren.

In diesem Modul werden wir den Codegeruch unnötiger Ausnahmen untersuchen, bei dem die übermäßige Verwendung von Ausnahmen die Behandlung von Ausnahmen komplizierter macht als nötig. Sie werden lernen, wie Sie die Behandlung von Ausnahmen vereinfachen können, um einen klareren und robusteren Code zu erhalten.

In diesem Modul werden wir den Codegeruch von flachen Modulen besprechen, bei denen die Module im Verhältnis zu ihrer Komplexität wenig Funktionalität enthalten. Sie werden lernen, wie Sie diese Module refactorieren können, um eine sinnvollere Funktionalität bereitzustellen und die Wiederverwendbarkeit zu verbessern.

In diesem letzten Modul fassen wir die wichtigsten Erkenntnisse aus dem Kurs zusammen, unterstreichen die Bedeutung sauberer Code-Praktiken und geben Hinweise, wie Sie Ihre Fähigkeiten im Software-Design weiter verbessern können, um eine bessere Wartbarkeit und Skalierbarkeit zu erreichen.