Komplette Programmierphilosophie | Original, von KI übersetzt
Inhaltsverzeichnis
- Programmierung
- Programmierung als kreative Tätigkeit
- Entwicklung persönlicher Projekte
- Technologietrends und neugiergetriebenes Lernen
- Philosophie des Debuggens und Problemlösens
- Benutzerorientierte Entwicklung
- Code-Qualität und Einfachheit
- Integration von KI und Automatisierung
- Ein unbegrenzter Ingenieur werden
- Arbeiten unter Unternehmensbeschränkungen
- Maximierung interner Ressourcen
- Werkzeugbau im KI-Zeitalter
- Veränderung der Denkweise
- Überwindung wahrgenommener Grenzen
- Vorteile der Protokollsammlung
- Protokollverwaltung in Unternehmensumgebungen
- Historischer Kontext und Problemlösung
- Strategien zur Organisierung von Protokolldateien
- Langfristige Projektwartung
- Wissensbewahrung und -teilung
- Automatisierte Methoden zur Protokollsammlung
Programmierung
-
Es ist in Ordnung, Competitive Programming zu betreiben, solange es dich motiviert.
-
Programmieren ist wie Schreiben. Programmieren ist eine kreative Tätigkeit.
-
Arbeite an deinem eigenen Projekt. Schreibe deinen eigenen technischen Blog. Programmiere für ein Projekt, das du über Jahre pflegst, so wie einen 10 Jahre alten Blog.
-
Meistens musst du nicht den neuesten Technologietrends hinterherjagen, da viele davon nach ein paar Jahren verschwinden.
-
Folge deiner Neugier und programmiere für dich selbst.
-
Versuche, Programme für dich selbst zu erstellen. Sie sind keine Arbeitsaufträge.
-
Wenn du beim Programmieren oft unglücklich bist, machst du etwas falsch.
-
iOS, Android, Backend, Frontend, KI – alles ist gut. Man kann zumindest versuchen, ein kleines Projekt damit umzusetzen oder es ein paar Monate lang zu lernen.
-
Debuggen bedeutet, misstrauisch zu sein. Vertraue nicht jeder Zeile deines Codes; denke über einen besseren Weg nach.
-
Beim Programmieren ist sogar ein Zeichen oder eine Protokollzeile wichtig. Sie sagen dir etwas.
-
Programmieren bedeutet, Produkte für andere zu machen. Es ist interessant, Nutzer zu haben.
-
Du musst nicht hart sein. Ein paar hundert Nutzer, die dein Produkt lieben, sind besser als Zehntausende, die es nur oberflächlich mögen.
-
Denke daran, warum du mit dem Programmieren angefangen hast, und vergiss es nie.
-
Wende Programmierkenntnisse auf alle Lebensbereiche an. Sie sind gleich. Dinge stapelweise oder einzeln erledigen. Aufgaben in Einheiten unterteilen. Die Technologie hinter jeder App. Die feinen Details hinter Netzwerkanfragen.
-
Die Abstraktion und das logische Denken. Das detailorientierte Denken. Das Durchdenken jeder Lösung.
-
Wahrheit ist Wahrheit. Normalerweise liegt der Computer nicht falsch. Die Schaltung liegt nicht falsch. Der Compiler liegt nicht falsch. Sei nicht frustriert, wenn es einen Bug gibt.
-
Strebe nach eleganten und einfachen Lösungen. Einfachheit ist die höchste Form der Raffinesse. Du musst hart nachdenken, um das Wesentliche zu behalten und das Überflüssige zu entfernen.
-
Für Programmiersprachen sind die Sprachen, die die Arbeit erledigen, in Ordnung. Persönlich empfehle ich Java und Python.
-
Folgt Yin Wang unter https://www.yinwang.org. Er ist einer der wenigen Genies in der Programmierung, obwohl er sagt, dass Genies nicht existieren.
-
Die Kenntnisse und Prinzipien der Programmierung lassen sich leicht auf Sprachenlernen, Hardware-Reparatur, Life Hacking und wissenschaftliche Forschung anwenden.
-
Für die meisten Programmieraufgaben brauchst du keine ausgefallene Mathematik, außer Schulmathematik.
-
Betrachte deinen alten Code nach Jahren oder pflege ein Codeprojekt über lange Zeit. Es wird dich viel lehren.
-
Wenn du deine Leidenschaft fürs Programmieren verlierst, mache einfach eine Zeit lang etwas anderes.
-
Der Zeitpunkt des Testens ist wichtig. Mach es natürlich. Oft brauchst du keine Tests für dein Projekt zu schreiben. Versuche, keine Tests zu schreiben, Unit-Tests zu schreiben, Integrationstests zu schreiben, API-Tests zu schreiben. Vergleiche sie weise.
-
Probiere KI-Code-Editoren aus. Nutze ChatGPT oder andere Chatbots oft. Da KI-Tools jetzt einfach zu verwenden sind, kannst du dich auf kreativere oder wichtigere Teile konzentrieren.
-
Beim Debuggen überprüfe, ob du die neueste Version der Bibliotheken verwendest. Wenn eine Bibliothek nicht mehr gepflegt wird, suche nach aktiv gepflegten Klonen oder Forks.
-
Wenn du etwas wie Netzwerkgeschwindigkeit oder Programmlaufzeit verbessern willst, muss es ein quantitatives Maß geben. Sonst weißt du nicht genau, ob es eine triviale Verbesserung oder Verschlechterung gab.
-
Für persönliche Projekte ist es in Ordnung, keinen Testcode zu schreiben, aber es ist besser, nach einer größeren Codeänderung lokal zu testen. Berücksichtige den betroffenen Code, wie lange er in der Cloud-Pipeline läuft und wie oft er zu Fehlern führen könnte, und schreibe dann entsprechend Testcode. Verwende Methoden, die einfaches Testen ohne negative Auswirkungen auf die Benutzererfahrung ermöglichen.
-
Schreibe einfachen und eleganten Code. Vermeide Redundanz, obwohl sie manchmal zu einer einfacheren Lösung führt. Vermeide Sonderfälle. Mache es leicht zu testen. Refaktorisiere, um gemeinsame Funktionen oder Prozesse zu nutzen, verwende Rekursion oder Schleifen und suche nach Mustern.
-
Behandle Fehler richtig. Denke über die Ursache, die Verantwortung und ob wir sie ändern können oder ob es ein externer Fehler ist. Berücksichtige die Rettungsmethode, den Umfang der Auswirkungen, wo sie behandelt werden soll, ob wir Fehler kategorisieren sollten, wie wahrscheinlich es ist und die schlimmsten Szenarien.
-
Der Unterschied zwischen der Verwendung von replace oder startWith gefolgt von slice ist, dass Ersteres die Position des Strings ignoriert. Wende ähnliches Denken auf jedes Detail der Programmierung an.
-
Minimiere die möglichen Werte für ein Element; verwende nur einen Wert für einen Fall. Verwende nicht null, wenn wir bereits false haben. Wenn wir ein übersetztes true- oder false-Flag haben, müssen wir sicherstellen, dass wir das Fehlen eines übersetzten Flags nicht als false behandeln.
-
Verwende GitHub oder Sourcetree, um geänderte Codeblöcke häufig zu überprüfen. Sie sind bequemer zum Lesen von Code.
-
Beim Programmieren gibt es oft keine trivialen Dinge. Jedes Zeichen, die Reihenfolge der Listenelemente, jeder String, jede Zahl und jeder Variablenname ist wichtig. Jede Ausführungsreihenfolge und jedes Protokoll sind von Bedeutung.
-
Mache die Dinge, die dich am meisten begeistern. Du musst dir keine Sorgen machen, nicht dem Mainstream zu folgen.
-
Verwende Befehle häufig, da sie Aufgaben automatisieren oder mit LLMs helfen können. UI-Operationen sind schwerer zu automatisieren.
-
Speichere die Protokolle eines Programms, einschließlich lokaler, UAT-, Microservice- und Pipeline-Protokolle, in einem Verzeichnis. Beim Programmieren enthalten diese Protokolle zahlreiche Verbindungen. Durchsuche sie, um Beziehungen zu identifizieren, und sammle relevante Daten oder Kontext.
-
Mit gesammelten Protokollen ist es einfacher zu bestimmen, ob du ein Problem bereits einmal hattest. Aus früheren Protokollen weißt du vielleicht, wie du es beheben kannst. Protokolle geben ein besseres Verständnis dafür, wie alles funktioniert und wie Computer Programme ausführen. Im Gegensatz zu Code sind Protokolle zeitbezogen und bieten mehr Informationen über den Ausführungsstatus. Sie sind auch leichter für das Debugging.
-
Debugging zeigt viele Informationen, einschließlich der Werte umgebender Variablen, Thread-Namen und Funktionsstapel.
-
Automatisiere alles, wie Proxy-Updates und die Auswahl des besten Proxy-Servers. Verwende Python, um umfangreiche Skripte zu schreiben.
-
Halte die Dinge einfach, mache Funktionen klein und Dateien klein. Das macht sie leicht zu testen, zu überprüfen und mit einer Stichprobe zu prüfen.
-
Es ist das KI-Zeitalter, also nutze KI-Tools, um gründliche Tests durchzuführen und alles so perfekt wie möglich zu machen. Werfe Ausnahmen früher. Füge Tests für den Code hinzu und führe sie täglich in der Pipeline aus. Fehler sind in Ordnung, aber mache nicht denselben Fehler zweimal. Verhindere das mit Code-Überprüfung.
Ein unbegrenzter Ingenieur werden
-
Große Unternehmen haben strikte Sicherheitsrichtlinien, bei denen Mitarbeiter oder Auftragnehmer in der ersten Woche Laptops erhalten und sie bei ihrem Ausscheiden zurückgeben.
-
Projekte beinhalten viele Details, aber Mitarbeiter vergessen oft Informationen während ihrer Arbeit, besonders nach einem Jahr oder mehr.
-
Erinnerungen an die Erfahrung umfassen Projektumrisse, Teaminteraktionen und LinkedIn-Verbindungen, aber aufgrund strenger Informationskontrollen bleiben keine dokumentierten Aufzeichnungen.
-
Die erste Auftragserfahrung in solchen Unternehmen kann frustrierend sein, macht Softwareentwicklung schwieriger und beeinflusst die Arbeit erheblich.
-
Kürzlich habe ich herausgefunden, wie man die Umgebung unbegrenzt erscheinen lässt, indem man interne Ressourcen nutzt, auch wenn sie nicht wirklich uneingeschränkt ist.
-
Tausende Softwareoptionen sind verfügbar, besonders Compiler unter Windows, die das Erstellen von Skripten und kleinen Tools ermöglichen.
-
Lerne so viele Bibliotheken und Programmiersprachen wie möglich; maximiere die Nutzung dessen, was intern gegeben ist.
-
Es gibt Unterstützung für Sprachen wie Go, Rust, C/C++ Build-Tools, JavaScript mit npm und C#, was die Flexibilität mit mehr Wissen erhöht.
-
Im KI-Zeitalter baue eigene Tools wie Postman mit Python-Skripten oder schreibe Datenbankskripte, wenn Tools Funktionen fehlen.
-
Nutze KI, um Aufgaben zu automatisieren, wie Selenium-Skripte für Tests oder Leistungstest-Skripte.
-
Anfängliche Gefühle der Begrenzung in großen Unternehmen entsprangen der Denkweise, da Richtlinien das Bauen von Dingen oder effektives Arbeiten nicht verhindern.
-
Im Leben entstehen wahrgenommene Grenzen oft aus mangelndem tiefem Nachdenken; mehr Versuche können zu einzigartigen Ideen führen.
-
Ein unbegrenzter Ingenieur in großen Unternehmen zu werden bedeutet, insgesamt ein unbegrenzter Mensch zu werden.
Vorteile der Protokollsammlung
Als ich früher als Auftragnehmer für eine Bank arbeitete, nutzten wir eine Multi-Cloud-Anwendungsplattform, um die Microservices zu bedienen. Damals begann ich, Protokolle zu sammeln, als ich im Unternehmen arbeitete.
Einige Jahre sind vergangen, und ich denke immer noch, dass es eine der besten Möglichkeiten ist, mir bei der Arbeit oder Softwareentwicklung zu helfen. Im Laufe der Zeit gibt es in meinem Protokollverzeichnis Hunderte von Protokolldateien.
Ich habe keine spezifischen Unterverzeichnisse oder formale Protokolldateinamen dafür. Manchmal verwende ich einfach den JIRA-Aufgabennamen als Präfix für den Protokolldateinamen oder das Feature. Dann füge ich eine Nummer als Suffix hinzu. Zum Beispiel mutual-fund-1.log, mutual-fund-2.log usw. Das bedeutet, im Mutual-Fund-Microservice habe ich das Protokoll, als ich diesen Microservice ausführte.
Manchmal, wenn ich an Projekten arbeite, die mehrere Regionen bedienen, füge ich das Land als Suffix hinzu, wie mutual-fund-cn-1.log, mutual-fund-sg-1.log. Die Dateinamen der Protokolle sind irgendwie lässig. Denn damals musste ich mich auf Fehlerstapel oder umgebende Funktionsaufrufe konzentrieren.
Die Protokolle der Programme sind wichtig. Jeder weiß das. Aber ich möchte die Bedeutung der Protokollsammlung überbetonen, anstatt sie nur in der Konsole zu betrachten und gehen zu lassen. Du wirst mehr Bequemlichkeit erkennen, wenn das Projekt läuft. Du hast mehr Zeit, um frühere Protokolle zu finden. Vielleicht musst du wissen, ob ein ähnlicher Datenbank-Gespeicherter-Prozedur-Aufruf schon einmal passiert ist. Vielleicht musst du wissen, ob derselbe Fehler schon einmal aufgetreten ist. Vielleicht musst du dich erinnern, wie du das Problem das letzte Mal behoben hast.
In einem großen Projekt oder Dutzenden von Microservices gibt es Unmengen von Details. Und die Fehler, Ausnahmen oder Probleme passieren immer wieder. Das Protokoll ist wie das Laufdokument eines Programms. Und sie werden automatisch vom Programm generiert, ohne menschliche Eingabe. Und für Entwickler sind diese Protokolle lesbar. Wenn du also eine neue Aufgabe beginnst oder einen neuen Bug behebst, hast du Hunderte von Protokollen zur Hand, um diesen neuen Bug zu beheben. Du bist nicht allein.
Warum sammeln wir sie? Weil Dinge oder Wissen leicht vergessen werden.
Es gab menschlichen Fortschritt, als Papier erfunden wurde. Und als Computer erfunden wurden, gab es eine weitere Stufe der menschlichen Zivilisation. Notizen auf Papier zu halten ist wie Protokolle in Computern zu sammeln.
Nicht nur für Menschen, sondern auch für KI-Chatbots, LLM-Tools werden diese Protokolle immer wichtiger. Die GreptimeDB, eine Datenbank für die einheitliche Sammlung und Analyse von Beobachtungsdaten (Metriken, Protokolle und Spuren), die 2022 gegründet wurde, ist kein Zufall.
Warum habe ich das nicht früher gemacht? Nachdem ich als Auftragnehmer für große Banken gearbeitet hatte, musste ich mehr zusammenarbeiten und an größeren Projekten arbeiten. Davor arbeitete ich die meiste Zeit in Startups oder während meiner Startup-Phase allein. Als ich früher bei LeanCloud arbeitete, arbeitete ich etwa die Hälfte der Zeit an der IM-App LeanChat.
Und als ich in die formellere Unternehmenswelt eintrat, war die Entwicklung der Projekte anders als bei meinen persönlichen Projekten oder Startup-Projekten. Sie haben SIT-, UAT-Testumgebungen. Und die Produktionsumgebung ist oft nur für bestimmte kleine Teamkollegen geöffnet. Die Protokolle von ihnen zu bekommen und Probleme zu beheben, wird lang und etwas mühsam. Und das Ausführen eines Projekts dauert Zeit, und die Jenkins-Pipeline braucht oft eine halbe Stunde.
Daher kann ich das Programm nicht wie im Flug testen. Ich kann kein Deployment durchführen, indem ich einfach einen Befehl auf meinem persönlichen Computer eingebe und Code auf den Server hochlade, um ihn auszuführen.
Daher lässt es mich irgendwie Protokolle sammeln, um mehr Kontext für die Aufgabenbearbeitung zu haben. Wir sollten Probleme besser beim ersten Versuch beheben. Wir sollten unsere Korrekturen besser in wenigen Versuchen überprüfen. Wir können nicht leicht Protokolle des Programms bekommen, das in einer Cloud oder auf dem Server des Unternehmens läuft, also kopieren wir sie besser und speichern sie auf dem lokalen Laptop, um Analysen durchzuführen.
Und jetzt sammle ich auch für meine persönlichen Projekte Protokolle. Es ist eine Gewohnheit geworden. Nachdem ich einige Jahre in großen Unternehmen gearbeitet habe, habe ich irgendwie mehr Geduld oder Strategie, um meine Projekte größer und länger zu machen. Daher weiß ich, dass ich diese Protokolle mit der Zeit brauche.
Manche mögen sagen, dass du nur eleganten Code und ein funktionierendes Projekt brauchst. Du musst keine Protokolle oder Fehlerstapel sammeln. Das ist in Ordnung. Wenn wir einen Bug oder ein neues Feature haben, können wir das Programm ausführen, um die aktuellen Protokolle zu bekommen. Wir brauchen die Protokolle aus dem Entwicklungsprozess nicht. Sie sind wie detaillierte Aufzeichnungen wissenschaftlicher Experimente. Auf den ersten Blick scheint es okay. Aber langfristig, wenn du eines Tages wieder daran arbeiten willst oder es teilen oder andere übernehmen lassen willst, mag es nicht gut sein.
Ich denke, es könnte hier gute Möglichkeiten geben. Warum ermutigen wir in Unternehmen nicht jeden Entwickler, seine gesammelten Protokolle zu teilen? In Open-Source-Projekten sollten wir das auch haben. Wir finden die Protokolle anderer nicht ansprechend, weil wir sie nicht kennen. Wir verlieren den Kontext beim Speichern dieser Protokolle. Und darin scheinen Unmengen von unwichtigen oder trivialen Nachrichten zu sein.
Aber der Aufwand, Protokolle zu sammeln, ist nur trivial. Es ist nur Kopieren und Einfügen jedes Mal, wenn wir einige Protokolle sehen, besonders die Fehlerprotokolle. Und wie wäre es, wenn wir es automatisiert machen? Es ist eine gute Idee, die Protokolle jedes Mal, wenn wir ein Projekt ausführen, in einem Verzeichnis aufzuzeichnen, wie diese Spring-Boot-Projekte.
Die Welt wird immer digitaler, daher ist das Sammeln von Protokollen digitaler Programme wie das Sammeln von Büchern in einer physischen Welt.