Wer ist dieser Kerl? Was weiß er über das Schreiben von „großartigem“ Code?!

Mit dieser Annahme haben Sie zu 100 % Recht – und um ganz ehrlich zu sein … ich habe viel, viel mehr Erfahrung mit dem Schreiben von nicht großartigem Code.

Aus vielen Gründen wird kein guter Code geschrieben (einige sind unten aufgeführt).

1. es ist schwer
2. „großartig“ ist subjektiv
3. Software ist nie fertig (kann nicht großartig sein, muss großartig bleiben)
4. Die Qualität kann sich je nach aktuellen Anforderungen ändern
5. Viel funktionierende Software ist nicht toll (schlechte Vorbilder)
6. Menschen, die Software wollen, sind oft keine Softwareentwickler
7. …

Trotz meiner umfassenden Erfahrung mit suboptimalem Code habe ich fast ein Jahrzehnt Erfahrung damit, Computer (so freundlich wie möglich) zu bitten, die Dinge zu tun, die ich und andere Menschen wollen.

Im Laufe dieser Zeit habe ich verschiedene Konzepte und Muster schätzen gelernt und auch ein tiefes Misstrauen gegenüber anderen entwickelt.

In diesem Artikel werde ich einige der Vor- und Nachteile von Software skizzieren – und unterstützende Beweise von wirklich klugen Leuten liefern.

Willkommen bei der Fahrt

Was ist großartig"

Beginnen wir damit, zu definieren, was „großartig“ ist. Es könnte jedoch einfacher sein, es zu definieren, indem man schnell angibt, was es nicht ist.

Toller Code ist

1. nicht schwer zu lesen
2. nicht schwer, darüber nachzudenken
3. führt nicht dazu, dass Sie sich selbst hassen, weder heute noch 7 Tage nachdem Sie es geschrieben haben

1. 90 % Struktur und 10 % Syntax
2. eine Funktion der Informationsabstraktion gepaart mit vorhergesagtem Ressourcenmanagement
3. ein Freund der Mathematik (speziell Mengen-/Kategorientheorie)
4. geschrieben für Menschen, nicht für Hardware

1. 90 % Struktur und 10 % Syntax

Alle diese Ideen sind von viel umfassenderen und tiefergehenden Themen inspiriert. Bezüglich der Struktur können wir uns am SOLID-Programmierparadigma orientieren.

SOLID steht für eine Reihe von 5 „Regeln“, die befolgt werden sollten, um wartbare Software zu erstellen. Unten aufgeführte Konzepte

S - Single-responsiblity Principle
O - Open-closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

Diese Prinzipien drehen sich um die Leistungsfähigkeit der objektorientierten Programmierung (ich liebe sie oder hasse sie) und beschreiben eine elegante Möglichkeit, Ihre Abstraktionen in softwarefreundliche Teile zu unterteilen.

Durch die Befolgung dieser Prinzipien können Sie viele unangenehme Komplexitäten vermeiden, die bei funktionaler Software auftreten.

Mit den SOLID-Prinzipien reduzieren Sie beispielsweise den Platzbedarf Ihres Codes und konzentrieren Dateien auf allgemeine Funktionen. Dies erleichtert die Navigation und das Hinzufügen/Entfernen von Funktionen, ohne dass sich dies auf andere Teile Ihrer Codebasis auswirkt.

Diese Probleme werden auf der Strukturebene Ihrer Anwendung vollständig vermieden – und nicht auf der Codeebene

Sauberkeit auf Strukturebene ist eine wirksame Möglichkeit, eine dauerhafte Organisation durchzusetzen.

Leicht verständlicher Artikel über SOLID von Digital Ocean: hier

Als ob das noch nicht genug wäre – Onkel Bob hat weiterhin tolle Songs veröffentlicht .

Ich würde sein neueres Buch aus dem Jahr 2017 (und ehrlich gesagt auch alles neuere) wärmstens empfehlen.

„Saubere Architektur: Ein Leitfaden für Handwerker zur Softwarestruktur und zum Design“ –https://www.oreilly.com/library/view/clean-architecture-a/9780134494272/

In diesem Buch wird untersucht, wie Sie diese Konzepte auf die Systemebene erweitern können .

Da wir immer mehr Anwendungen in die „Cloud“ verlagern und verteilte Dienste nutzen. Diese Designprinzipien haben immer größeren Einfluss auf die Größe Ihres Codes.

Großartiger Code ist lediglich ein Werkzeug, das die Struktur Ihres Anwendungsdesigns ausfüllt. Ihr System sollte über seine Struktur und nicht über die Syntax ausgedrückt werden.

2. eine Funktion der Informationsabstraktion gepaart mit vorhergesagtem Ressourcenmanagement

ähm... was. Damit hast du mich wirklich verloren. eine Funktion von waa?

Lass es uns aufschlüsseln.

„Eine Funktion der Informationsabstraktion“ ist eine prägnante Möglichkeit auszudrücken, dass unser Code die Ausgabe unserer Abstraktionen ist .

Mit anderen Worten: Unser Code spiegelt unsere Entscheidung wider, die Konzepte unserer Anwendung aufzuteilen.

Konkreter; Wenn wir vor einem Problem stehen und beschließen, „Benutzer“ und „Sitzungen“ zu erstellen, haben wir unser Problem effektiv in diese abstrakten Ideen von Benutzern und Sitzungen zerlegt.

…okay Ich denke, wir haben die „Funktion der Informationsabstraktion“ abgedeckt.

Als nächstes kombinieren wir das mit „vorhergesagtem Ressourcenmanagement“, was eine schicke Art ist zu sagen, dass Softwareentwickler die Aufgabe haben, in die Zukunft zu blicken – und Systeme zu bauen, die zukünftigen Veränderungen standhalten

Wenn Sie es nicht wussten: Es ist Ihre Schuld als Programmierer, dass Sie das neueste Framework ein Jahr vor seiner Erstellung nicht verwendet haben. Woher wusstest du das nicht!? (Bitte als Sarkasmus verstehen – ich verspreche, das ist nicht persönlich).

Um es zusammenzufassen: Die Qualität unseres Codes hängt nicht immer von der Rechenkomplexität, der Anzahl der Zeilen oder eleganten Variablennamen ab.

Es ist die Fähigkeit, Ihr Problem effektiv in abstrakte Teile zu zerlegen , die den unvorhersehbaren Veränderungen von morgen standhalten.

Ja ja ja, ich weiß; das scheint nicht möglich zu sein. Nun, das ist nicht der Fall – und es ist unsere Aufgabe als Entwickler, die Dinge zu verwalten, die wir wissen, und die Dinge, von denen wir wissen, dass wir sie nicht wissen.

Es handelt sich um eine Übung zur Risikobewertung und Kostenplanung – ich wusste nicht, dass Sie sich dafür angemeldet haben, oder?

Es gibt jedoch Hoffnung!

Durch die Befolgung vertrauenswürdiger Konzepte (weitere folgen in Kürze) können wir uns und unsere Anwendungen für eine sich verändernde Welt wappnen.

Bevor wir zu den wirklich guten Dingen kommen, können wir hier einige „vertrauenswürdige“ Ideen anerkennen.

• Standardisierungsgremien (es gibt Leute, die sich bereits intensiv Gedanken darüber gemacht haben – und sie würden es wirklich schätzen, wenn Sie ihre großartige Arbeit nutzen würden. Dies gilt insbesondere für Algorithmen, Sicherheit, Cross-Plattform und andere wirklich wichtige Dinge wie QR-Codes.)
• Statische und stark typisierte Sprachen (ehrlich gesagt geht es hier nicht wirklich um die niedrigen Sicherheitsprobleme, die Sie vermeiden werden. Es geht um die menschenzentrierte Natur von Typen. Erstens: Wenn Sie den Typ in Ihrem Code verletzen, wird der Compiler Sie anschreien, und Zweitens wissen andere Entwickler tatsächlich, was Ihr Code tut.
• Poesie (weniger um die Wörter als vielmehr um die Fähigkeit, komplexe Bedeutungen mit wenigen Symbolen zu kommunizieren. Ihr Code ist Poesie, auch wenn er ein sehr einfallsloses Publikum anspricht, sollte sich aber dennoch kurz und bündig lesen).

Auch wenn das vielleicht nicht der Fall ist – Ihr Code sollte mit der Mathematik kompatibel sein.

Ja, ich weiß – Mathe ist langweilig und Sie haben im wirklichen Leben noch nie eine Ableitung verwendet.

Aber…. Ich verspreche es – es kann super hilfreich sein. Es ist tatsächlich das vertrauenswürdigste Tool, das wir haben.

Es ist vertrauenswürdig, weil es auf eine lange Geschichte von Open-Source-Beiträgen zurückblickt und die meisten Fehler in der Kernsoftware behoben wurden. Jetzt sind die Entwickler (Mathematiker) damit beschäftigt, verrückte Dinge wie die Quantenphysik herauszufinden.

Wir können auf nützliche Dinge wie Kryptografie vertrauen, um unsere Bankkonten und Kommunikation zu sichern. Wir können darauf vertrauen, dass die Mengentheorie das Typsystem von [HIER LIEBLINGSPROGRAMMIERSPRACHE HINZUFÜGEN] durchsetzt. Wir können sogar so weit gehen, der linearen Algebra zu vertrauen, um unsere Route auf Google Maps zu optimieren, und ChatGPT, um alberne Dinge zu vermeiden.

Es ist wichtig, sich daran zu erinnern, dass unsere Computer hinter all der schicken Benutzeroberfläche und dem glänzenden Bildschirm genau das sind; Computer.

Wenn man alle Komplexitäten ausblendet, bleiben nur noch die Grundlagen der Addition und Subtraktion.

Vielleicht, nur vielleicht ... gibt es eine Möglichkeit, all diese Leistung in unseren eigenen Code zu übertragen.

Lasst uns etwas tiefer eintauchen

Ich stelle eine wilde Vermutung an und gehe davon aus, dass Sie (der Leser) mit objektorientierter Programmierung vertraut sind.

Und ... ich gehe auch so weit zu vermuten, dass Sie von funktionaler Programmierung gehört haben – aber beschlossen haben, dass Sie das an einem anderen Tag lernen sollten.

Wenn Sie zu diesem Lager gehören, sind Sie sich möglicherweise nicht der Schönheit und Eleganz von Programmiersprachen bewusst, die der Semantik der traditionellen Mathematik besser folgen.

Wir (normale Menschen) sind mit den Abstraktionen, die die Mainstream-Sprachen bieten, verwöhnt. Wir gehen davon aus, dass wir Variablen erstellen können, wann immer wir wollen, und komplexe Kontrollflüsse mit Türmen von ifund konstruieren könnenelse

Wir (normale Menschen) sollten jedoch auf unser intelligenteres Gegenstück zur funktionalen Programmierung achten.

In einfachen und einschränkenden Sprachen stecken verborgene Superkräfte. Sie bieten beweisbare ( ⚡️ durch Mathematik unterstützte ) Methoden, um zu zeigen, dass Ihr Code alle Fälle abdeckt oder dass er in einzelne Arbeitsschritte zerlegt werden kann, die auf unendlich viele Maschinen verteilt werden können.

Unendlichkeit und Beweise sind für den durchschnittlichen Programmierer schwierige Ideen, aber jeder Mathematiker isst sie zum Frühstück.

Einer dieser Superhelden im Video unten zeigt beispielsweise, wie die Modellierung eines Systems Möglichkeiten bieten kann, Schritt-für-Schritt-Anleitungen zu finden, um unglaublich komplexe Fehler auszunutzen, ohne einen Blick auf den tatsächlichen Code zu werfen

Das Geheimnis liegt in der Leistungsfähigkeit der formalen Mathematik, die auf das Systemdesign angewendet wird.

Bei richtiger Anwendung (und nein, dazu ist nicht das Umschreiben aller Dinge in einer funktionalen Sprache erforderlich) erhalten Sie alle Vorteile der Mathematik kostenlos.

Zu diesen Vorteilen zählen unter anderem:

• Automatische Generierung von Tests für jede mögliche Verwendungsmöglichkeit Ihres Programms
• Erkunden Sie die Auswirkungen des Hinzufügens entfernter Komponenten oder Systeme zu Ihrer Anwendung
• Seien Sie zu 100 % sicher, dass der Code funktioniert. Sie möchten wirklich sicher sein, dass die Software für Ihr Flugzeugfahrwerk funktioniert, nicht wahr?
• andere komplexere Dinge, die Ihnen die Sprecher in diesem Video beibringen können. Oh, und wenn Sie es wirklich ernst meinen, das zu lernen, schauen Sie sich TLA+ an

Vielleicht können wir einige dieser unglaublich langweiligen Konzepte nutzen, um unseren Code langweilig und erstaunlich zu machen.

Guter Code sollte danach streben, so konkrete Ideen zu haben, dass dieselben Ideen auch in mehr als 1000 Jahren wahr sind

Pathagotem entwickelte etwa 570 v. Chr. eine großartige Software für Dreiecke. das ist wie vor 1500 Jahren!

Vielleicht sollten wir von Mathematik lernen oder sie nutzen, wenn möglich – sie ist für uns Menschen die beste Möglichkeit, dauerhafte Abstraktionen auszudrücken.

4. für Menschen geschrieben, nicht für Hardware

Ok, was die Mathe-Sachen angeht. Wenn wir über Software sprechen – so sehr versuchen wir auch, den Menschen zu meiden. Sie kommen immer ins Spiel.

Reden wir über Menschen. Wie passen Menschen dazu?

Nun ja... sie sind diejenigen, die die Software überhaupt wollen, und tatsächlich sind sie diejenigen, die diese Sprachen erfunden haben.

Darüber hinaus sind sie diejenigen, denen die ganze Sache am Herzen liegt – Computer haben keine Meinung über den Code, den sie ausführen.

Menschen tun. Menschen definieren, was „funktioniert“ und was nicht.

Also – ich denke, wir sollten alles am Menschenrecht ausrichten?

Ja! Und das bedeutet nicht nur, dass wir hübsche Benutzeroberflächen und ergonomische mobile Apps brauchen.

Wir müssen die Menschlichkeit in die Softwareentwicklung einbeziehen. Das sollten wir auf vielen Ebenen spüren .

Die Menschheit sollte auf allen Ebenen in die Entwicklererfahrung einbezogen werden. Im Folgenden finden Sie einige Fragen, die den Menschen in den Mittelpunkt stellen.

• Die Leute werden in Codebasen integriert. Ermöglicht Ihre Dokumentation dies?
• Wie viele Tools/Befehle oder spezielle Einrichtungsschritte muss ich ausführen?
• Wie sieht es aus, einen neuen Test hinzuzufügen? eine neue Funktion?
• Wie viele Frameworks/Sprachen erfordert Ihr Projekt? Könnte es weniger sein?
• Wie hoch ist der Aufwand, um von einem völlig neuen Produkt auf ein vollständig in Produktion befindliches Produkt umzusteigen?
• Wie sieht es mit dem Brechen aus? Und muss ich aufwachen, um das Problem zu beheben?

Aber ein kleines Team guter Entwickler ist mehr als die Summe seiner Einzelteile (wenn es richtig gemacht wird).

Wie bekommen wir also großartigen Code aus einem Team?

Einige Lösungen sind einfacher als andere. Eine einfache, aber effektive Möglichkeit besteht beispielsweise darin, alles zu standardisieren – die gesamte Persönlichkeit aus einzelnen Beiträgen zu entfernen.

Auch wenn das hart klingt, wird ein solides System bestimmte Arten/Typen/Muster haben, um Dinge zu tun. Die Syntax des Codes sollte nur sehr wenig Anpassung und Kreativität enthalten.

Warum ist das eine gute Sache? Es entlastet den Entwickler erheblich. Wenn es einen „Weg“ gibt, etwas zu tun, dann sollte es auch so gemacht werden.

Dadurch wird die Lösung effektiv von der Codeebene auf die Strukturebene verschoben (bereits erwähnt). Denn wir müssen uns auf Entscheidungen und Muster auf Systemebene verlassen und nicht auf maßgeschneiderte.

Einfacher ausgedrückt: Alle Entwickler sollten gemeinsame Typen verwenden. Dies macht Anpassungen überflüssig und erleichtert die Integration verschiedener Entwicklerarbeiten erheblich.

Diese Idee sollte weit über Typen hinausgehen und je mehr Konzepte effektiv auf Systemebene standardisiert werden können, desto umfangreicher wird Ihr Code.

Großartiger Code ist so gut geschrieben, dass die Beiträge verschiedener Teammitglieder oft nicht von anderen Teilen der Codebasis zu unterscheiden sind. Außerdem sollten Sie nicht sehen können, wo eine Person angefangen hat und eine andere beendet hat.

Im folgenden Video werden Strategien zum Aufbau von Teams und zur Steigerung der Produktivität bei zunehmender Komplexität eines Systems im Detail erläutert.

Dies ist ein faszinierendes Thema, da die Ideen des komplexen Systemdesigns weit über den Bereich von Computern hinausgehen und natürliche Phänomene wie Tier-/Pflanzenbiologie, soziale Interaktionen und Planeten berühren.

Wir Normalsterblichen/Entwickler haben eine Menge Macht in unseren Händen. Wir können riesige Haufen komplexer und nutzloser Scheiße aufbauen – und mit denselben Händen können wir unsere eigenen komplexen dynamischen Systeme aufbauen, die sich nicht wesentlich von dem Planeten unterscheiden, auf dem ich dies schreibe.

Bis zum nächsten Mal, programmieren Sie weiter, verbreiten Sie Liebe und Frieden ✌️