Als Programmierer besteht Ihre Aufgabe darin, Code zu schreiben, der korrekt funktioniert und das gewünschte Ergebnis liefert. Allerdings muss der Code auch leicht zu verstehen, zu warten und zu erweitern sein. Um dieser Herausforderung gerecht zu werden, ist es notwendig, die Schlüsselkonzepte der Programmierung mit den Prinzipien guter Codierung zu kombinieren.
In diesem Beitrag teile ich meine zehn wichtigsten Programmierprinzipien, die Ihnen helfen sollen, die Art und Weise, wie Sie Code schreiben, zu verbessern und Ihnen, Ihren Mitentwicklern und Ihren Endbenutzern das Leben zu erleichtern.
Warum sind Programmierprinzipien wichtig?
Wenn Sie einige Programmierprinzipien lernen und sie in Ihrem Code anwenden, werden Sie ein besserer Entwickler. Das Befolgen dieser Vorgehensweisen verbessert die Gesamtqualität des Codes und macht es für Sie oder andere Personen einfacher, in Zukunft Änderungen vorzunehmen oder Funktionen hinzuzufügen.
Bildquelle: Großzügig
Programmierprinzipien helfen Ihnen, Probleme wie verwirrenden oder übermäßig komplexen Code, Programme, die bei einer einzigen Einstellung abstürzen, und Variablen, die keinen Sinn ergeben, zu vermeiden. Wenn Sie sich daran halten, können Sie auch erfolgreicher zusammenarbeiten, indem Sie sicherstellen, dass andere Programmierer Ihren Code verstehen können.
Unabhängig davon, ob Sie ein Basisprogramm oder eine Anwendung auf Unternehmensebene erstellen, lohnt es sich, sich mit diesen 10 Prinzipien vertraut zu machen.
Zehn Programmierprinzipien, die es zu befolgen gilt:
1. KUSS (Keep it simple, dumm!)
Es ist eines der wichtigsten Programmierprinzipien, Ihren Code einfach und sauber zu halten. Einige Entwickler geben gerne an, indem sie zu langen oder fortgeschrittenen Code schreiben, aber selbst wenn er clever erscheint, ist der Code möglicherweise nicht besonders klar.
Sie sollten stets darauf achten, dass Ihr Code leicht verständlich ist. Wenn Sie ein Skript in einer Zeile schreiben können, tun Sie es! Sie könnten ein komplexes Problem in kleinere Teile zerlegen oder unnötigen Code entfernen. Das Ziel besteht darin, Komplexität zu reduzieren und Probleme zu lösen, und nicht darin, Menschen zu beeindrucken.
Die Verwendung klarer Variablennamen ist eine weitere Möglichkeit, es einfach zu halten. Denken Sie daran, vorhandene Codierungsbibliotheken und -tools zu nutzen.
2. Wiederholen Sie sich nicht (DRY)
Programmierer lieben Akronyme, oder? Dieser ist leicht zu merken: Er weist Sie darauf hin, den Code nicht zu wiederholen. Wiederholungen sind ein häufiger Fehler, denn wenn Sie Daten, Logik oder Funktionen duplizieren, wird Ihr Code lang und die Wartung, Fehlerbehebung oder Änderung nimmt mehr Zeit in Anspruch.
Das Wiederholen umfasst das Kopieren und Einfügen von Code in Ihr Programm. Anstatt Zeilen zu duplizieren, ist es besser, einen Algorithmus zu finden, der eine Schleife verwendet, da es viel einfacher ist, eine Schleife zu debuggen, die 20 Wiederholungen verarbeitet, als 20 Codeblöcke, die jeweils eine Wiederholung verarbeiten.
Das Gegenteil des DRY-Prinzips ist (natürlich) WET, was für „Write Everything Twice or Waste Everyone’s Time“ steht. Beides ist keine gute Idee.
Bildquelle: technologisches Ziel
3. Du wirst es nicht brauchen (YAGNI)
Zu einem ähnlichen Thema sollten Sie keinen Code schreiben, nur für den Fall, dass Sie ihn in Zukunft benötigen. Mit anderen Worten: Das YAGNI-Prinzip fordert Sie auf, Code nur für die aktuelle Situation zu schreiben, anstatt zu versuchen, ein Problem zu lösen, das nicht existiert.
Features und Funktionalität sollten nur bei Bedarf hinzugefügt werden. Andernfalls wird Ihre Software oder Ihr Programm größer und komplexer als nötig. YAGNI geht auf die Softwareentwicklungsmethodik Extreme Programming (XP) zurück, die darauf abzielt, Ineffizienz zu reduzieren.
Programmierer verstoßen manchmal gegen diesen Grundsatz, wenn sie versuchen, DRY-Codierungspraktiken einzuhalten. Behalten Sie also beides im Hinterkopf.
4. Dokumentieren Sie Ihren Code
Nun, Sie haben Ihren Code geschrieben und verstehen ihn (hoffe ich!). Aber nur weil es für Sie Sinn ergibt, heißt das nicht, dass es auch für jemand anderen klar ist. Sie können Ihren Entwicklerkollegen helfen, indem Sie Ihren Code mit Kommentaren dokumentieren und die Benennung Ihrer Variablen und Funktionen verbessern.
Wenn Sie beispielsweise einen Anrufweiterleitungsalgorithmus für den Einsatz in VoIP-Callcenter-Lösungen entwerfen, könnten Sie Kommentare hinterlassen, um die verschiedenen Funktionen zu erläutern und sie für andere Entwickler oder Tester verständlicher zu machen.
In allen Programmiersprachen können Sie Ihrem Code Kommentare hinzufügen, Sie sollten sich also daran gewöhnen. Ja, es ist ein wenig Mehrarbeit, aber es ist wichtig, wenn man mit anderen zusammenarbeitet. Und wenn Sie den Code in ein paar Monaten noch einmal ändern, werden Sie es nicht bereuen!
Bildquelle: Sie kann programmieren
5. Aufsatz zum Thema Vererbung
Wenn Sie bereits geschriebenen Code wiederverwenden, gibt es zwei Möglichkeiten: Vererbung und Komposition. Die meisten Programmierer bevorzugen die Komposition (obwohl Vererbung ihre Vorteile hat, schließen Sie sie also nicht vollständig aus).
Das Prinzip der Komposition vor der Vererbung ist besonders nützlich, wenn Sie objektorientierte Programmierung oder OOP verwenden (die eigentlich über eigene Prinzipien verfügt). Darin heißt es, dass Objekte mit komplexem Verhalten Instanzen von Objekten mit individuellem Verhalten enthalten müssen; Sie sollten keine Klasse erben und neue Verhaltensweisen hinzufügen.
Durch die Vererbung werden Klassenframeworks schnell unhandlich, was zu unzähligen Klassen führt, die Ihren Anforderungen möglicherweise nicht entsprechen. Klassenhierarchien lassen sich nach ihrer Implementierung nur schwer ändern, da Sie eine Oberklasse nicht ändern können, ohne das Risiko einzugehen, dass die Unterklasse eines Benutzers beschädigt wird. Und es gibt weniger Flexibilität bei der Definition von Sonderfallverhalten.
Die Kompositionsprogrammierung ist sauberer zu schreiben und einfacher zu warten und bietet eine einfachere, besser testbare Codebasis. Ermöglicht Verhaltensweisen, die Flexibilität definieren: Sie können Klassen für einfache Ergänzungen oder Änderungen entwerfen und die Erstellung von Komponenten verzögern, bis sie benötigt werden.
6. Offen/Geschlossen
Wenn Sie eine Bibliothek oder ein Framework veröffentlichen, die andere verwenden werden, ist „Offen/Geschlossen“ ein wichtiges Prinzip. Das bedeutet, dass Softwareartefakte wie Klassen und Module offen für Erweiterungen, aber gesperrt für Änderungen sind. Dadurch wird der Code stabiler und einfacher zu warten.
Angenommen, Sie werden gebeten, Code für die Agenturvertragsvorlage eines E-Signatur-Softwareunternehmens zu schreiben>. Sie veröffentlichen eine Version des Frameworks, damit Programmierer diese direkt ändern und in ihren veröffentlichten Code integrieren können. Wenn Sie jedoch in Zukunft ein größeres Update veröffentlichen, wird der Code kaputt gehen. Es ist am besten, Code zu veröffentlichen, der Erweiterungen fördert und gleichzeitig direkte Änderungen vermeidet, um das Risiko der Einführung neuer Fehler zu minimieren.
7. Einzelverantwortung
Dieses Prinzip besagt, dass jede Klasse oder jedes Modul in einem Programm nur eine bestimmte Funktionalität bereitstellen sollte und es nicht mehr als einen Grund für die Änderung einer Klasse geben sollte. Das Ziel besteht darin, die Vervielfachung von Nebenwirkungen oder Verantwortlichkeiten in einer einzelnen Methode oder Klasse zu vermeiden.
Bildquelle: Halb
Der Unterricht wird komplizierter, wenn Sie zu viele Verantwortlichkeiten hinzufügen, und es ist schwieriger, zusätzliche Funktionen für ein bestimmtes Modul zu erstellen. Am besten ist es, sie in kleinere Klassen und Module zu unterteilen, um die Isolierung eines bestimmten Moduls zur Fehlerbehebung zu erleichtern.
Einzelverantwortung und Offen/Geschlossen sind Teil der von Robert C. Martin festgelegten SOLID-Prinzipien (die anderen sind Liskov-Substitution, Schnittstellentrennung und Abhängigkeitsumkehr).
8. SoC: Trennung der Belange
Dieses Programmierprinzip ist eine abstrakte Version der Einzelverantwortung. SoC besagt, dass ein Programm mit verschiedenen Containern entworfen werden sollte, die keinen Zugriff aufeinander haben sollten. Jeder Codeteil ist völlig unabhängig.
Dabei handelt es sich um eine Möglichkeit, eine komplizierte Anwendung in verschiedene Abschnitte oder Domänen zu unterteilen, von denen jeder eine bestimmte Aufgabe erfüllt oder ein anderes Anliegen anspricht. Dies erleichtert die Wartung, Aktualisierung, Wiederverwendung und Fehlerbehebung Ihres Codes.
Ein bekanntes Beispiel ist das Model-View-Controller (MVC)-Layout, das derzeit in gängigen Web-Frameworks verwendet wird. Ein Programm ist in drei verschiedene Abschnitte unterteilt: Daten (Modell), Logik (Controller) und das, was der Endbenutzer sieht (Ansicht), und jeder Abschnitt wird unabhängig behandelt.
9. Minimieren Sie die Kopplung
Codekopplung tritt auf, wenn zwei Module oder zwei Schichten ein gewisses Maß an gegenseitiger Abhängigkeit aufweisen, z. B. wenn sie Code gemeinsam nutzen oder Zugriff auf dieselben Daten haben. Dies kann zu Problemen führen, einschließlich Code, der schwer zu befolgen und zu warten ist.
Wenn ein Entwickler beispielsweise seine API-Endpunkte mit einer bestimmten Ansicht in einer Frontend-Anwendung kombiniert, beispielsweise einem Telefonsystem mit mehreren Leitungen, kann der Endpunkt nicht für eine andere Ansicht, beispielsweise eine mobile Anwendung, wiederverwendet werden. (Sie fragen sich vielleicht: Was ist ein Telefonsystem mit mehreren Leitungen?)
Programmierer müssen verstehen, wie Code miteinander gekoppelt ist, um die Kopplung zu minimieren, was bedeutet, dass sie die Verantwortlichkeiten jeder Schicht verstehen müssen. Durch die Einzelverantwortung wird auch die Kopplung zwischen einzelnen Softwarekomponenten und Code verringert.
Bildquelle: Manning
10. Refaktorieren
Codebasen entwickeln sich ständig weiter, sodass es Zeiten geben wird, in denen Sie ganze Codeabschnitte überprüfen, neu schreiben oder neu gestalten müssen. Betrachten Sie dies nicht als Misserfolg Ihres ersten Versuchs, sondern als Lernmöglichkeit.
Code umgestalten bedeutet, ihn zu überprüfen und nach Möglichkeiten zu suchen, ihn zu optimieren, effizienter zu machen und die Ergebnisse genau gleich zu halten. Allerdings sollten Sie eine vorzeitige Optimierung vermeiden. Optimieren Sie Ihren Algorithmus nicht in der frühen Entwicklungsphase, da Sie Engpässe nicht vorhersagen können und sich die Anforderungen ändern können.
Abschließende Gedanken
Wenn wir diese Liste auf ein Schlüsselprinzip reduzieren würden, wäre es dieses: Sorgen Sie dafür, dass Ihr Code leicht verständlich und wartbar ist. Mehrere der Programmierprinzipien auf unserer Liste verfolgen diesen Zweck, von KISS und DRY bis hin zur Einzelverantwortung und Dokumentation Ihres Codes.
Wenn Sie diese Prinzipien befolgen, können Sie einfachen Code erstellen, der tut, was er tun soll, und den andere verstehen können. Und Sie wissen, wann der richtige Zeitpunkt für die Optimierung ist. Ein letzter Ratschlag: Lernen Sie weiter, um sich weiter zu verbessern.
