Ich hoffe, das ist keine allzu allgemeine Frage. Ich könnte wirklich einen erfahrenen Rat gebrauchen.

Ich bin neu als einziger "SW-Ingenieur" in einem relativ kleinen Geschäft von Wissenschaftlern beschäftigt, die in den letzten 10 bis 20 Jahren eine riesige Codebasis zusammengeschustert haben. (Es wurde in einer praktisch veralteten Sprache geschrieben: G2 - denke Pascal mit Grafiken). Das Programm selbst ist ein physikalisches Modell einer komplexen chemischen Aufbereitungsanlage. Das Team, das es geschrieben hat, verfügt über unglaublich tiefgreifende Fachkenntnisse, hat jedoch keine oder nur geringe formale Ausbildung in Programmiergrundlagen. Sie haben kürzlich einige schwierige Lektionen über die Konsequenzen des nicht vorhandenen Konfigurationsmanagements gelernt. Ihre Wartungsbemühungen werden auch durch die große Anhäufung von undokumentiertem "Schlamm" im Code selbst stark behindert. Ich werde Ihnen die "Politik" der Situation ersparen (es gibt immer Politik!), aber es gibt keinen Konsens darüber, was für den weiteren Weg erforderlich ist.

Sie haben mich gebeten, dem Team einige der Prinzipien der modernen Softwareentwicklung vorzustellen. Sie möchten, dass ich einige der branchenüblichen Vorgehensweisen und Strategien in Bezug auf Codierungskonventionen, Lebenszyklusmanagement, allgemeine Entwurfsmuster und Quellcodeverwaltung vorstelle. Ehrlich gesagt ist es eine ziemlich entmutigende Aufgabe und ich bin mir nicht sicher, wo ich anfangen soll.

Anfangs bin ich geneigt, sie in einigen der zentralen Konzepte von The Pragmatic Programmer oder Fowlers Refactoring ("Code Smells" usw.) zu unterrichten. Ich hoffe auch, eine Reihe von agilen Methoden einzuführen. Aber letztendlich denke ich, um effektiv zu sein, muss ich mich auf 5-7 Grundprinzipien konzentrieren. Mit anderen Worten, was sind die wichtigsten Prinzipien oder Praktiken, mit deren Umsetzung sie realistisch beginnen können, und die ihnen das meiste "Geld für Geld" einbringen.

Das ist also meine Frage: Was würden Sie in Ihre Liste der effektivsten Strategien aufnehmen, um die Spaghetti zu glätten (und dies in Zukunft zu verhindern)?

Vorwort

Dies ist in der Tat eine gewaltige Aufgabe, und es gibt viel zu tun. Ich schlage dies demütig als etwas umfassenden Leitfaden für Ihr Team vor, mit Hinweisen auf geeignete Tools und Lehrmaterialien.

Denken Sie daran: Hierbei handelt es sich um Richtlinien , die je nach den Umständen übernommen, angepasst oder gestrichen werden sollen.

Achtung: All dies auf einmal in ein Team zu werfen würde höchstwahrscheinlich scheitern. Sie sollten versuchen, Elemente auszuwählen, die Ihnen den besten Schweiß geben, und sie nacheinander langsam einführen.

Hinweis: Dies gilt nicht für alle visuellen Programmiersysteme wie G2. Ausführlichere Informationen zum Umgang mit diesen finden Sie im Abschnitt Nachtrag am Ende.

Executive Summary für den Ungeduldigen

• Definieren Sie eine starre Projektstruktur mit:
  • Projektvorlagen ,
  • Kodierungskonventionen ,
  • vertraute Build-Systeme ,
  • und Richtlinien für die Verwendung Ihrer Infrastruktur und Tools.
• Installieren Sie ein gutes SCM und vergewissern Sie sich, dass es verwendet werden kann.
• Weisen Sie sie auf gute IDEs für ihre Technologie hin und stellen Sie sicher, dass sie wissen, wie sie verwendet werden.
• Implementieren Sie Code-Qualitätsprüfungen und automatische Berichte im Build-System.
• Koppeln Sie das Build-System mit kontinuierlichen Integrations- und Inspektionssystemen .
• Mit Hilfe der oben genannten, identifiziert Codequalität „Hotspots“ und Refactoring .

Nun zur Langfassung ... Achtung, macht euch bereit!

Die Steifheit ist (oft) gut

Dies ist eine kontroverse Meinung, da Rigidität oft als eine Kraft gesehen wird, die gegen Sie arbeitet. Dies gilt für einige Phasen einiger Projekte. Wenn Sie es jedoch als strukturelle Unterstützung betrachten, als Framework, das das Rätselraten überflüssig macht, wird der Zeit- und Arbeitsaufwand erheblich reduziert. Lass es für dich funktionieren, nicht gegen dich.

Starrheit = Prozess / Verfahren .

Die Softwareentwicklung benötigt gute Prozesse und Verfahren aus genau den gleichen Gründen, aus denen Chemiewerke oder Fabriken Handbücher, Verfahren, Bohrer und Notfallrichtlinien haben: Vermeidung von schlechten Ergebnissen, Erhöhung der Vorhersagbarkeit, Maximierung der Produktivität ...

Die Starrheit kommt jedoch in Maßen!

Starrheit der Projektstruktur

Wenn jedes Projekt eine eigene Struktur hat, sind Sie (und Neuankömmlinge) verloren und müssen jedes Mal von vorne anfangen, wenn Sie sie öffnen. Sie wollen das nicht in einem professionellen Software-Shop, und Sie wollen das auch nicht in einem Labor.

Starrheit der Build-Systeme

Wenn jedes Projekt anders aussieht , ist die Wahrscheinlichkeit groß, dass es auch anders aufgebaut ist . Ein Build sollte nicht zu viel Forschung oder Rätselraten erfordern. Sie tun möchten , müssen in der Lage die kanonische Sache und nicht um Einzelheiten kümmern: configure; make install, ant, mvn install, etc ...

Die Wiederverwendung desselben Build-Systems und dessen zeitliche Weiterentwicklung gewährleisten ebenfalls ein gleichbleibendes Qualitätsniveau.

Sie müssen schnell READMEauf die Projektspezifikationen eingehen und den Benutzer / Entwickler / Forscher, falls vorhanden, ordnungsgemäß führen.

Dies erleichtert auch andere Teile Ihrer Build-Infrastruktur erheblich:

• kontinuierliche Integration ,
• kontinuierliche inspektion .

Halten Sie Ihr Build (wie auch Ihre Projekte) auf dem neuesten Stand, machen Sie es jedoch im Laufe der Zeit strenger und melden Sie Verstöße und schlechte Praktiken effizienter.

Erfinden Sie das Rad nicht neu und verwenden Sie das, was Sie bereits getan haben.

Literatur-Empfehlungen:

• Kontinuierliche Integration: Verbesserung der Softwarequalität und Reduzierung des Risikos (Duval, Matyas, Glover, 2007)
• Continuous Delivery: Release von Sotware-Releases durch Build-, Test- und Deployment-Automatisierung (Humble, Farley, 2010)

Starrheit in der Wahl der Programmiersprache

Insbesondere in einer Forschungsumgebung ist nicht zu erwarten, dass alle Teams (und noch weniger alle Entwickler) denselben Sprach- und Technologiestapel verwenden. Sie können jedoch eine Reihe von "offiziell unterstützten" Tools identifizieren und deren Verwendung fördern. Der Rest sollte ohne eine gute Begründung nicht erlaubt sein (über das Prototyping hinaus).

Halten Sie Ihren Tech-Stack einfach und die Wartung und Breite der erforderlichen Fähigkeiten auf ein Minimum: einen starken Kern.

Starrheit der Kodierungskonventionen und -richtlinien

Mithilfe von Kodierungskonventionen und -richtlinien können Sie sowohl eine Identität als Team als auch eine gemeinsame Umgangssprache entwickeln . Sie möchten sich nicht jedes Mal in terra incognita vertiefen, wenn Sie eine Quelldatei öffnen.

Unsinnige Regeln, die das Leben erschweren oder Handlungen in dem Maße explizit verbieten, in dem Verpflichtungserklärungen aufgrund einfacher Verstöße abgelehnt werden, sind eine Belastung. Jedoch:

• Ein gut durchdachter Grundregelsatz nimmt viel Jammern und Denken weg: Niemand sollte unter keinen Umständen brechen.

• und eine Reihe von empfohlenen Regeln bieten zusätzliche Anleitungen.

Persönlicher Ansatz: Ich bin aggressiv, wenn es um Codierungskonventionen geht, manche sagen sogar Nazi , weil ich daran glaube, eine Verkehrssprache zu haben , einen erkennbaren Stil für mein Team. Wenn Mistcode eingecheckt wird, fällt er auf wie ein Lippenherpes im Gesicht eines Hollywood-Stars: Er löst automatisch eine Überprüfung und eine Aktion aus. In der Tat bin ich manchmal so weit gegangen, die Verwendung von Pre-Commit-Hooks zu befürworten, um nicht konforme Commits abzulehnen. Wie bereits erwähnt, sollte es nicht übermäßig verrückt sein und der Produktivität im Wege stehen. Es sollte es vorantreiben. Führen Sie diese langsam ein, besonders am Anfang. Aber es ist viel besser, als so viel Zeit damit zu verbringen, fehlerhaften Code zu reparieren, dass Sie nicht an echten Problemen arbeiten können.

Einige Sprachen erzwingen dies sogar von Haus aus:

• Java sollte die Menge des langweiligen Mülls reduzieren, den Sie damit schreiben können (obwohl es zweifellos viele schaffen, dies zu tun).

• Pythons Blockstruktur durch Einrücken ist eine andere Idee in diesem Sinne.

• Gehen Sie mit seinem gofmtWerkzeug, das jede Debatte und Anstrengung ( und jedes Ego !! ), die dem Stil innewohnt , vollständig beseitigt: Laufen gofmtSie, bevor Sie sich verpflichten.

Stellen Sie sicher, dass der Code rot nicht durchrutschen kann. Code-Konventionen , kontinuierliche Integration und Inspektion , Paarprogrammierung und Code-Reviews sind Ihr Arsenal gegen diesen Dämon.

Wie Sie weiter unten sehen werden, handelt es sich bei Code um Dokumentation. Dies ist ein weiterer Bereich, in dem Konventionen die Lesbarkeit und Klarheit fördern.

Starrheit der Dokumentation

Dokumentation geht Hand in Hand mit Code. Code selbst ist Dokumentation. Aber es muss klare Anweisungen geben, wie man Dinge baut, benutzt und wartet.

Es ist eine gute Sache, einen einzigen Kontrollpunkt für die Dokumentation zu verwenden (wie ein WikiWiki oder DMS). Erstellen Sie Räume für Projekte, Räume für mehr zufällige Scherze und Experimente. Lassen Sie alle Leerzeichen gemeinsame Regeln und Konventionen wiederverwenden. Versuchen Sie, es Teil des Teamgeistes zu machen.

Die meisten Ratschläge zu Code und Werkzeugen gelten auch für die Dokumentation.

Starrheit in Codekommentaren

Code-Kommentare, wie oben erwähnt, sind ebenfalls Dokumentationen. Entwickler mögen es, ihre Gefühle zu ihrem Code auszudrücken (meistens Stolz und Frustration, wenn Sie mich fragen). Daher ist es nicht ungewöhnlich, dass sie diese in Kommentaren (oder sogar im Code) in eindeutigen Begriffen ausdrücken, wenn ein formellerer Text dieselbe Bedeutung mit weniger Explosionen oder Dramen hätte vermitteln können. Es ist in Ordnung, aus Spaß und aus historischen Gründen ein paar durchzulassen: Es ist auch Teil der Entwicklung einer Teamkultur . Aber es ist sehr wichtig, dass jeder weiß, was akzeptabel ist und was nicht, und dass Kommentarrauschen genau das ist: Rauschen .

Starrheit in Commit-Protokollen

Commit-Protokolle sind kein ärgerlicher und nutzloser "Schritt" in Ihrem SCM-Lebenszyklus: Sie können sie NICHT überspringen, um pünktlich nach Hause zu kommen oder mit der nächsten Aufgabe fortzufahren oder die Freunde einzuholen, die zum Mittagessen abgereist sind. Sie sind wichtig und wie (die meisten) guten Weine werden sie umso wertvoller, je mehr Zeit vergeht. Also mach sie richtig. Ich bin verblüfft, wenn ich sehe, dass Kollegen Einzeiler für Riesen-Commits oder für nicht offensichtliche Hacks schreiben.

Commits werden aus einem bestimmten Grund durchgeführt, und dieser Grund wird durch Ihren Code und die von Ihnen eingegebene Zeile des Commit-Protokolls nicht immer klar ausgedrückt. Da steckt noch mehr dahinter.

Jede Codezeile hat eine Geschichte und eine Geschichte . Die Diffs können ihre Geschichte erzählen, aber Sie müssen ihre Geschichte schreiben.

Warum habe ich diese Zeile aktualisiert? -> Weil sich die Oberfläche geändert hat.

Warum hat sich die Oberfläche geändert? -> Weil die Bibliothek L1, die sie definiert, aktualisiert wurde.

Warum wurde die Bibliothek aktualisiert? -> Weil die Bibliothek L2, die wir für die Funktion F benötigen, von der Bibliothek L1 abhing.

Und was ist Feature X? -> Siehe Aufgabe 3456 im Issue Tracker.

Es ist nicht meine SCM-Wahl und möglicherweise auch nicht die beste für Ihr Labor. Aber Gitdas stimmt und versucht, Sie zu zwingen, gute Protokolle mehr als die meisten anderen SCM-Systeme zu schreiben, indem Sie short logsund verwenden long logs. Verknüpfen Sie die Aufgaben-ID (ja, Sie benötigen eine) und hinterlassen Sie eine allgemeine Zusammenfassung für die shortlogund erweitern Sie das lange Protokoll: Schreiben Sie die Geschichte des Änderungssatzes .

Es ist ein Protokoll: Es ist hier, um Updates zu verfolgen und aufzuzeichnen.

Faustregel: Wenn Sie später nach etwas über diese Änderung suchen, ist es wahrscheinlich, dass Ihr Protokoll Ihre Frage beantwortet?

Projekte, Dokumentation und Code sind LEBENDIG

Halte sie synchron, sonst bilden sie nicht mehr diese symbiotische Einheit. Es wirkt Wunder, wenn Sie:

• Commit-Protokolle in Ihrem SCM löschen, mit Links zu Aufgaben-IDs in Ihrem Issue-Tracker,
• Wo die Tickets dieses Trackers selbst auf die Changesets in Ihrem SCM verweisen (und möglicherweise auf die Builds in Ihrem CI-System),
• und ein Dokumentationssystem, das mit all diesen verknüpft ist.

Code und Dokumentation müssen kohärent sein .

Starrheit beim Testen

Faustregeln:

• Jeder neue Code muss (mindestens) Unit-Tests enthalten.
• Jeder überarbeitete Legacy-Code wird mit Komponententests geliefert.

Natürlich brauchen diese:

• etwas Wertvolles zu testen (oder es ist Zeit- und Energieverschwendung),
• gut geschrieben und kommentiert sein (genau wie jeder andere Code, den Sie einchecken).

Sie dienen auch als Dokumentation und helfen dabei, den Vertrag Ihres Codes zu umreißen. Vor allem, wenn Sie TDD verwenden . Auch wenn Sie dies nicht tun, brauchen Sie sie für Ihre Seelenruhe. Sie sind Ihr Sicherheitsnetz, wenn Sie neuen Code (Wartung oder Funktion) einbauen, und Ihr Wachturm, um sich vor Code-Verrottung und Umweltschäden zu schützen.

Natürlich sollten Sie noch weiter gehen und Integrationstests und Regressionstests für jeden reproduzierbaren Fehler durchführen, den Sie beheben.

Starrheit im Gebrauch der Werkzeuge

Es ist in Ordnung, dass der gelegentliche Entwickler / Wissenschaftler einen neuen statischen Prüfer an der Quelle ausprobieren, ein Diagramm oder Modell mit einem anderen erstellen oder ein neues Modul mit einem DSL implementieren möchte. Am besten ist es jedoch, wenn es einen kanonischen Satz von Tools gibt, die alle Teammitglieder kennen und verwenden müssen.

Lassen Sie die Mitglieder darüber hinaus verwenden, was sie wollen, solange sie ALLE sind:

• produktiv ,
• NICHT regelmäßig Hilfe benötigen
• NICHT regelmäßig an Ihre allgemeine Infrastruktur anpassen ,
• NICHT die Infrastruktur stören (indem Sie allgemeine Bereiche wie Code, Build-System, Dokumentation ... ändern),
• NICHT die Arbeit anderer beeinflussen ,
• Ist in der Lage, jede angeforderte Aufgabe rechtzeitig auszuführen .

Wenn dies nicht der Fall ist, stellen Sie sicher, dass sie auf die Standardeinstellungen zurückgreifen.

Starrheit gegen Vielseitigkeit, Anpassungsfähigkeit, Prototyping und Notfälle

Flexibilität kann gut sein. Es ist in Ordnung, jemanden gelegentlich einen Hack, einen Quick-n-Dirty-Ansatz oder ein Lieblingswerkzeug für Haustiere verwenden zu lassen, um die Arbeit zu erledigen . NIEMALS lassen Sie es sich zur Gewohnheit geworden, und nie dieser Code die tatsächliche Code - Basis zu unterstützen , werden lassen.

Teamgeist ist wichtig

Entwickeln Sie ein Gefühl von Stolz in Ihrer Codebasis

• Entwickeln Sie ein Gefühl von Pride in Code
  • Verwenden Sie Wallboards
    • Rangliste für ein kontinuierliches Integrationsspiel
    • Wallboards für Issue Management und Fehlerzählung
  • Verwenden Sie einen Issue-Tracker / Bug-Tracker

Vermeiden Sie Schuldzuweisungen

• Verwenden Sie Continuous Integration / Continuous Inspection-Spiele: Sie fördern einen artgerechten und produktiven Wettbewerb .
• Behalten Sie die Fehler im Auge: Es ist nur eine gute Haushaltsführung.
• Machen Sie die Ursachen ausfindig : Es handelt sich nur um zukunftssichere Prozesse.
• ABER KEINE Schuldzuweisung : Es ist kontraproduktiv.

Es geht um den Code, nicht um die Entwickler

Machen Sie Entwickler auf die Qualität ihres Codes aufmerksam, ABER lassen Sie sie den Code als eigenständige Entität und nicht als Erweiterung ihrer selbst sehen, was nicht kritisiert werden kann.

Es ist ein Paradox: Sie müssen die egolose Programmierung für einen gesunden Arbeitsplatz fördern , sich aber aus Motivationsgründen auf das Ego verlassen.

Vom Wissenschaftler zum Programmierer

Leute, die Code nicht schätzen und stolz darauf sind, produzieren keinen guten Code. Damit diese Immobilie entstehen kann, müssen sie herausfinden, wie wertvoll und unterhaltsam sie sein kann. Bloße Professionalität und der Wunsch, Gutes zu tun, reichen nicht aus: Es braucht Leidenschaft. Sie müssen Ihre Wissenschaftler also (im weitesten Sinne) zu Programmierern machen .

Jemand argumentierte in Kommentaren, dass nach 10 bis 20 Jahren in Bezug auf ein Projekt und seinen Code jeder das Gefühl einer Bindung haben würde. Vielleicht irre ich mich, aber ich gehe davon aus, dass sie stolz auf die Ergebnisse des Codes und auf die Arbeit und das Erbe sind, nicht auf den Code selbst oder auf die Handlung, ihn zu schreiben.

Erfahrungsgemäß betrachten die meisten Forscher das Codieren als Notwendigkeit oder bestenfalls als unterhaltsame Ablenkung. Sie wollen nur, dass es funktioniert. Diejenigen, die sich bereits gut auskennen und ein Interesse an der Programmierung haben, sind viel leichter davon zu überzeugen, Best Practices und Switching-Technologien zu übernehmen. Sie müssen sie auf halbem Weg dorthin bringen.

Die Pflege von Codes ist Teil der Forschungsarbeit

Niemand liest beschissene Forschungsarbeiten. Das ist der Grund, warum sie von Fachleuten begutachtet, Korrektur gelesen, verfeinert, umgeschrieben und immer wieder genehmigt werden, bis sie als zur Veröffentlichung bereit gelten. Gleiches gilt für eine Diplomarbeit und eine Codebasis!

Machen Sie deutlich, dass die ständige Überarbeitung und Aktualisierung einer Codebasis das Verrotten des Codes verhindert, die technische Verschuldung verringert und die spätere Wiederverwendung und Anpassung der Arbeit für andere Projekte erleichtert.

Warum das alles??!

Warum beschäftigen wir uns mit all dem? Für die Codequalität . Oder ist es Qualitätscode ...?

Diese Richtlinien zielen darauf ab, Ihr Team zu diesem Ziel zu bewegen. Einige Aspekte tun es, indem sie ihnen einfach den Weg zeigen und ihn tun lassen (was viel besser ist), und andere nehmen sie an der Hand (aber so bilden Sie Menschen aus und entwickeln Gewohnheiten).

Woher weißt du, wann das Ziel in Reichweite ist?

Qualität ist messbar

Nicht immer quantitativ, aber messbar . Wie bereits erwähnt, müssen Sie ein Gefühl des Stolzes in Ihrem Team entwickeln, und Fortschritte und gute Ergebnisse sind der Schlüssel. Messen Sie regelmäßig die Codequalität und zeigen Sie den Fortschritt zwischen den Intervallen und wie wichtig er ist. Machen Sie Rückblicke, um darüber nachzudenken, was getan wurde und wie es die Dinge verbessert oder verschlechtert hat.

Es gibt großartige Werkzeuge für die kontinuierliche Inspektion . Sonar ist in der Java-Welt sehr beliebt, kann sich jedoch an alle Technologien anpassen. und es gibt viele andere. Behalten Sie Ihren Code unter dem Mikroskop und suchen Sie nach diesen nervigen Insekten und Mikroben.

Aber was ist, wenn mein Code schon Mist ist?

All das ist lustig und niedlich wie ein Ausflug nach Nimmerland, aber es ist nicht so einfach, wenn Sie bereits (einen Haufen dampfenden und stinkenden) Mistcodes haben und ein Team nur ungern Änderungen vornimmt.

Hier ist das Geheimnis: Sie müssen irgendwo anfangen .

Persönliche Anekdote: In einem Projekt haben wir mit einer Codebasis gearbeitet, die ursprünglich mehr als 650.000 Java-LOC, mehr als 200.000 JSP-Zeilen, mehr als 40.000 JavaScript-LOC und mehr als 400 MB Binärabhängigkeiten aufwies.

Nach ungefähr 18 Monaten sind es 500.000 Java LOC (MOSTLY CLEAN) , 150.000 Zeilen JSPs und 38.000 JavaScript LOC mit Abhängigkeiten von nur noch knapp 100 MB (und diese sind nicht mehr in unserem SCM enthalten!).

Wie haben wir das gemacht? Wir haben einfach alles gemacht. Oder versuchte es hart.

Es ist eine Teamleistung, aber wir langsam injizieren in unseren Prozessvorschriften und Werkzeugen , um die Herzfrequenz unseres Produktes zu überwachen, während hastig zerschneiden das „Fett“ weg: Mist Code, nutzlos Abhängigkeiten ... Wir haben nicht aufhören , alle Entwicklung Tun Sie dies: Wir haben gelegentlich Phasen relativen Friedens und relativer Ruhe, in denen wir frei sind, die Codebasis zu verrückt zu machen und sie zu zerreißen. Meistens tun wir dies jedoch alles, indem wir bei jeder sich bietenden Chance auf einen Überprüfungs- und Refaktormodus zurückgreifen : während des Builds, während des Mittagessens, während der Sprints zur Fehlerbehebung, während der Freitagnachmittage ...

Es gab einige große "Werke" ... Die Umstellung unseres Build-Systems von einem riesigen Ant-Build mit über 8500 XML-LOC auf einen Maven-Build mit mehreren Modulen war eine davon. Wir hatten dann:

• klare Module (oder zumindest war es schon viel besser und wir haben noch große Pläne für die Zukunft),
• automatisches Abhängigkeitsmanagement (zur einfachen Wartung und Aktualisierung sowie zum Entfernen unnötiger Abhängigkeiten),
• schnellere, einfachere und reproduzierbare Builds,
• Tägliche Qualitätsberichte.

Ein weiteres Problem war die Einführung von "Utility-Tool-Belts", obwohl wir versucht haben, Abhängigkeiten zu verringern: Google Guava und Apache Commons reduzieren Ihren Code und die Oberfläche für Fehler in Ihrem Code erheblich.

Wir haben auch unsere IT-Abteilung davon überzeugt, dass die neuen Tools (JIRA, Fisheye, Crucible, Confluence, Jenkins) möglicherweise besser sind als die vorhandenen. Wir mussten uns noch mit einigen, die wir verachteten, auseinandersetzen (QC, Sharepoint und SupportWorks ...), aber es war eine insgesamt verbesserte Erfahrung, mit etwas mehr Platz.

Und jeden Tag gibt es ein Rinnsal zwischen einem und Dutzenden von Commits, die sich nur mit dem Reparieren und Umgestalten von Dingen befassen. Wir brechen gelegentlich Dinge auf (Sie benötigen Komponententests und schreiben sie besser auf, bevor Sie sie überarbeiten), aber insgesamt war der Nutzen für unsere Moral UND für das Produkt enorm. Wir erhalten dort jeweils einen Bruchteil eines Prozentsatzes der Codequalität. Und es macht Spaß zu sehen, wie es zunimmt !!!

Hinweis: Auch hier muss die Steifheit geschüttelt werden, um Platz für neue und bessere Dinge zu schaffen. In meiner Anekdote hat unsere IT-Abteilung teilweise Recht, wenn sie versucht, uns einige Dinge aufzuzwingen , und ist für andere falsch. Oder vielleicht hatten sie früher recht . Dinge ändern sich. Beweisen Sie, dass dies bessere Möglichkeiten zur Steigerung Ihrer Produktivität sind. Hierfür stehen Probeläufe und Prototypen zur Verfügung.

Der Super-Secret Incremental Spaghetti Code Refactoring Cycle für hervorragende Qualität

       +-----------------+      +-----------------+
       |  A N A L Y Z E  +----->| I D E N T I F Y |
       +-----------------+      +---------+-------+
                ^                           |
                |                           v
       +--------+--------+      +-----------------+
       |    C L E A N    +<-----|      F I X      |
       +-----------------+      +-----------------+

Sobald Sie einige Qualitätswerkzeuge an Ihrem Werkzeuggürtel haben:

1. Analysieren Sie Ihren Code mit Code-Qualitätsprüfern.

   Linters, statische Analysatoren oder was haben Sie.

2. Identifizieren Sie Ihre kritischen Hotspots UND niedrig hängenden Früchte .

   Verstöße haben Schweregrade, und große Klassen mit einer großen Anzahl von Schwerengraden sind eine große rote Fahne: Als solche erscheinen sie als "Hotspots" auf den Ansichtstypen "Radiator" / "Heatmap".

3. Korrigieren Sie zuerst die Hotspots.

   Es maximiert Ihre Wirkung in kurzer Zeit, da sie den höchsten Geschäftswert haben. Im Idealfall sollten kritische Verstöße sofort behoben werden, da sie potenzielle Sicherheitslücken oder Absturzursachen darstellen und ein hohes Risiko darstellen, eine Haftung auszulösen (und in Ihrem Fall eine schlechte Leistung für das Labor).

4. Bereinigen Sie die Verstöße auf niedriger Ebene mit automatisierten Codebasis-Sweeps .

   Dadurch wird das Signal-Rausch-Verhältnis verbessert, sodass Sie möglicherweise erhebliche Verstöße auf Ihrem Radar sehen können, sobald sie auftreten. Anfangs gibt es oft eine große Armee von geringfügigen Verstößen, wenn man sich nie darum gekümmert hat und Ihre Codebasis in freier Wildbahn freigelassen wurde. Sie stellen kein wirkliches "Risiko" dar, beeinträchtigen jedoch die Lesbarkeit und Wartbarkeit des Codes. Korrigieren Sie sie entweder, wenn Sie sie bei der Arbeit an einer Aufgabe treffen, oder, wenn möglich, durch umfangreiche Bereinigungsaufträge mit automatisierten Code-Sweeps. Seien Sie vorsichtig bei großen Auto-Sweeps, wenn Sie keine gute Testsuite und kein Integrationssystem haben. Stellen Sie sicher, dass Sie mit den Mitarbeitern den richtigen Zeitpunkt vereinbaren, um sie zu führen, um den Ärger zu minimieren.

5. Wiederholen, bis Sie zufrieden sind.

   Was Sie im Idealfall niemals sein sollten, wenn dies noch ein aktives Produkt ist: Es wird sich ständig weiterentwickeln.

Schnelle Tipps für eine gute Haushaltsführung

• Im Hotfix-Modus basierend auf einer Kundensupportanfrage:

  • Es ist in der Regel eine bewährte Methode , andere Probleme NICHT zu beheben, da Sie möglicherweise unfreiwillig neue Probleme einführen.
  • Machen Sie es wie mit SEAL: Steigen Sie ein, töten Sie den Käfer, steigen Sie aus und versenden Sie Ihren Patch. Es ist ein chirurgischer und taktischer Schlag.

• In allen anderen Fällen ist es jedoch Ihre Pflicht, wenn Sie eine Datei öffnen:

  • auf jeden Fall: überprüfen Sie es (Notizen machen, Datei Problemberichte),
  • Vielleicht: Clean it (Stilbereinigungen und kleinere Verstöße),
  • ideal: refactor es (reorganisieren große abschnitte und ihre nachbarn).

Lassen Sie sich nur nicht davon abbringen, eine Woche von Datei zu Datei zu verbringen und am Ende Tausende von Korrekturen vorzunehmen, die sich über mehrere Funktionen und Module erstrecken - dies erschwert die Nachverfolgung in der Zukunft. Ein Problem im Code = ein Ticket in Ihrem Tracker. Manchmal kann sich ein Änderungssatz auf mehrere Tickets auswirken. aber wenn es zu oft passiert, dann machst du wahrscheinlich etwas falsch.

Anhang: Verwalten von visuellen Programmierumgebungen

Die ummauerten Gärten maßgeschneiderter Programmiersysteme

Mehrere Programmiersysteme, wie das G2 des OP, sind verschiedene Biester ...

• Kein Quellcode

  Oft haben Sie keinen Zugriff auf eine Textdarstellung Ihres Quellcodes: Er wird möglicherweise in einem proprietären Binärformat gespeichert oder speichert Dinge im Textformat, versteckt sie jedoch vor Ihnen. Maßgeschneiderte grafische Programmiersysteme sind in Forschungslabors keine Seltenheit, da sie die Automatisierung sich wiederholender Datenverarbeitungsabläufe vereinfachen.

• Kein Werkzeug

  Das heißt, abgesehen von ihren eigenen. Sie sind häufig durch ihre Programmierumgebung, ihren eigenen Debugger, ihren eigenen Interpreter, ihre eigenen Dokumentationswerkzeuge und -formate eingeschränkt. Es handelt sich um ummauerte Gärten , außer wenn sie irgendwann das Interesse einer Person wecken, die motiviert genug ist, ihre Formate umzuentwickeln und externe Tools zu erstellen - sofern die Lizenz dies zulässt.

• Fehlende Dokumentation

  Sehr oft sind dies Nischen-Programmiersysteme, die in relativ geschlossenen Umgebungen eingesetzt werden. Leute, die sie häufig benutzen, unterschreiben NDAs und sprechen nie darüber, was sie tun. Programmiergemeinschaften für sie sind selten. Ressourcen sind also knapp. Sie sind mit Ihrer offiziellen Referenz festgefahren, und das war's.

Das ironische (und oft frustrierende) Problem ist, dass all die Dinge, die diese Systeme tun, offensichtlich durch die Verwendung von Standard- und Allzweck-Programmiersprachen erreicht werden könnten und höchstwahrscheinlich effizienter. Aber es erfordert tiefere Programmierkenntnisse, während Sie nicht erwarten können, dass Ihr Biologe, Chemiker oder Physiker (um nur einige zu nennen) genug über das Programmieren weiß und noch weniger Zeit (und Lust) hat, es umzusetzen (und zu warten). komplexe Systeme, die langlebig sein können oder nicht. Aus dem gleichen Grund verwenden wir DSLs, wir haben diese maßgeschneiderten Programmiersysteme.

Persönliche Anekdote 2:Eigentlich habe ich selbst an einem gearbeitet. Ich habe die Verknüpfung mit der Anfrage des OP nicht hergestellt, aber mein Projekt bestand aus einer Reihe miteinander verbundener umfangreicher Datenverarbeitungs- und Datenspeichersoftware (hauptsächlich für die Bioinformatikforschung, das Gesundheitswesen und Kosmetika, aber auch für Unternehmen) Intelligence oder jeder Bereich, der die Verfolgung großer Mengen von Forschungsdaten jeglicher Art und die Vorbereitung von Datenverarbeitungs-Workflows und ETLs erfordert). Eine dieser Anwendungen war ganz einfach eine visuelle IDE mit den üblichen Funktionen: Drag-and-Drop-Schnittstellen, versionierte Projektarbeitsbereiche (mit Text- und XML-Dateien zum Speichern von Metadaten), viele steckbare Treiber für heterogene Datenquellen und eine visuelle Canvas zum Entwerfen von Pipelines, um Daten aus N Datenquellen zu verarbeiten und am Ende M transformierte Ausgaben zu generieren, und mögliche glänzende Visualisierungen und komplexe (und interaktive) Online-Berichte. Ihr typisches visuelles Programmiersystem nach Maß, das an einem gewissen NIH-Syndrom leidet und den Anspruch hat, ein System zu entwickeln, das an die Bedürfnisse der Benutzer angepasst ist.

Und wie zu erwarten ist es ein schönes System, das für seine Anforderungen recht flexibel ist, wenn auch manchmal etwas übertrieben, so dass Sie sich fragen, warum Sie nicht stattdessen Befehlszeilentools verwenden sollten, und das leider immer mittelgroß ist Teams, die an großen Projekten mit vielen verschiedenen Personen arbeiten und diese mit unterschiedlichen "Best Practices" verwenden.

Großartig, wir sind zum Scheitern verurteilt! - Was tun wir dagegen?

Nun, am Ende gilt all das noch. Wenn Sie den größten Teil der Programmierung nicht aus diesem System extrahieren können, um mehr Mainstream-Tools und -Sprachen zu verwenden, müssen Sie sie "nur" an die Einschränkungen Ihres Systems anpassen.

Informationen zu Versionierung und Speicherung

Am Ende kann man fast immer Version Dinge, auch mit der meisten eingeschränkten und ummauerten Umgebung. Meistens werden diese Systeme immer noch mit einer eigenen Versionierung ausgeliefert (die leider oft recht einfach ist und lediglich die Möglichkeit bietet, ohne große Sichtbarkeit auf frühere Versionen zurückzugreifen, wobei lediglich frühere Snapshots aufbewahrt werden). Es werden nicht genau die Änderungssätze verwendet, die von Ihrem SCM ausgewählt wurden, und es ist wahrscheinlich nicht für mehrere Benutzer geeignet, die gleichzeitig Änderungen einreichen.

Wenn sie jedoch eine solche Funktionalität bieten, besteht Ihre Lösung möglicherweise darin, die oben genannten, geliebten Industriestandard-Richtlinien zu befolgen und auf dieses Programmiersystem zu übertragen !!

Wenn es sich bei dem Speichersystem um eine Datenbank handelt, werden wahrscheinlich Exportfunktionen verfügbar gemacht oder es kann auf Dateisystemebene gesichert werden. Wenn es ein benutzerdefiniertes Binärformat verwendet, können Sie möglicherweise einfach versuchen, es mit einem VCS zu versionieren, das Binärdaten gut unterstützt. Sie werden keine genaue Kontrolle haben, aber zumindest sind Sie gegen Katastrophen abgesichert und verfügen über ein gewisses Maß an Disaster Recovery-Konformität.

Über das Testen

Implementieren Sie Ihre Tests in der Plattform selbst und richten Sie mithilfe externer Tools und Hintergrundjobs regelmäßige Sicherungen ein. Wahrscheinlich starten Sie diese Tests genauso, wie Sie die mit diesem Programmiersystem entwickelten Programme starten würden.

Sicher, es ist ein Hackjob und entspricht definitiv nicht dem Standard, der für "normale" Programmierung üblich ist, aber die Idee ist, sich an das System anzupassen, während versucht wird, einen Anschein eines professionellen Softwareentwicklungsprozesses aufrechtzuerhalten.

Die Straße ist lang und steil ...

Wie immer bei Nischenumgebungen und maßgeschneiderten Programmiersystemen und wie oben dargestellt, haben Sie es mit seltsamen Formaten zu tun, nur mit einer begrenzten (oder überhaupt nicht existierenden) Menge möglicherweise klobiger Werkzeuge und einer Lücke anstelle einer Community.

Die Empfehlung: Versuchen Sie, die obigen Richtlinien so weit wie möglich außerhalb Ihres maßgeschneiderten Programmiersystems zu implementieren. Dies stellt sicher, dass Sie sich auf "gängige" Tools verlassen können, die eine angemessene Unterstützung und Community-Unterstützung bieten.

Die Problemumgehung: Wenn dies keine Option ist, versuchen Sie, dieses globale Framework in Ihre "Box" nachzurüsten. Die Idee ist, diese Blaupause von Best Practices nach Industriestandard über Ihr Programmiersystem zu legen und das Beste daraus zu machen. Der Rat gilt weiterhin: Struktur und Best Practices definieren, Konformität fördern.

Leider bedeutet dies, dass Sie möglicherweise eintauchen und eine enorme Menge an Beinarbeit leisten müssen. Damit...

Berühmte letzte Worte und bescheidene Wünsche:

• Dokumentieren Sie alles, was Sie tun.
• Teilen Sie Ihre Erfahrungen.
• Open Source jedes Tool, das Sie schreiben.

Auf diese Weise werden Sie:

• Erhöhen Sie nicht nur Ihre Chancen, Unterstützung von Menschen in ähnlichen Situationen zu erhalten,
• Sie können aber auch anderen Menschen helfen und Diskussionen rund um Ihren Technologiestapel anregen.

Wer weiß, Sie könnten ganz am Anfang einer neuen lebendigen Community von Obscure Language X stehen . Wenn es keine gibt, starte eine!

• Fragen zu Stack Overflow stellen ,
• Vielleicht schreibe ich sogar einen Vorschlag für eine neue StackExchange-Site in Area 51 .

Vielleicht ist es innen wunderschön , aber bisher hat niemand eine Ahnung , also helfen Sie, diese hässliche Mauer niederzureißen und lassen Sie andere einen Blick darauf werfen!

Der allererste Schritt wäre die Einführung eines Versionskontrollsystems (SVN, Git, Mercurial, TFS usw.). Dies ist ein Muss für ein Projekt, das über ein Re-Factoring verfügt.

Bearbeiten: in Bezug auf VSC - Jedes Quellcodeverwaltungspaket kann Binärdateien verwalten, allerdings mit einigen Einschränkungen. Die meisten Tools auf dem Markt können einen benutzerdefinierten Unterschieds-Viewer und -Editor verwenden. Verwenden Sie diese Funktion. Binäre Quelldateien sind keine Entschuldigung dafür, die Versionskontrolle nicht zu verwenden.

Es gibt einen ähnlichen Beitrag zum Umgang mit Legacy-Code . Es ist möglicherweise eine gute Referenz, die Sie befolgen sollten - Hinweise zum Arbeiten mit Legacy-Code

Wenn ich mit Spaghetti-Code arbeiten muss, arbeite ich zuerst an der Modularisierung . Suchen Sie Orte, an denen Sie Linien zeichnen und (mehr oder weniger) unabhängige Teile der Codebasis extrahieren können. Sie werden wahrscheinlich nicht sehr klein sein, da sie in hohem Maße miteinander verbunden und gekoppelt sind, aber einige Modullinien entstehen, wenn Sie nach ihnen suchen.

Sobald Sie Module haben, stehen Sie nicht mehr vor der entmutigenden Aufgabe, ein komplettes chaotisches Programm zu bereinigen. Stattdessen müssen Sie jetzt mehrere kleinere, unabhängige, unordentliche Module bereinigen. Wählen Sie nun ein Modul und wiederholen Sie dies in kleinerem Maßstab. Suchen Sie nach Stellen, an denen Sie große Funktionen in kleinere Funktionen oder sogar Klassen extrahieren können (sofern G2 diese unterstützt).

Dies ist alles viel einfacher, wenn die Sprache über ein ausreichend starkes Typensystem verfügt, da Sie den Compiler dazu bringen können, einen Großteil der Last für Sie zu heben. Sie nehmen irgendwo eine Änderung vor, die (absichtlich) die Kompatibilität beeinträchtigt, und versuchen dann zu kompilieren. Die Kompilierungsfehler führen Sie direkt zu den Stellen, die geändert werden müssen, und wenn Sie nicht mehr darauf zugreifen, haben Sie alles gefunden. Dann starte das Programm und teste alles! Kontinuierliche Tests sind beim Refactoring von entscheidender Bedeutung.

Ich weiß nicht, ob dies eine Option für Sie ist, aber ich würde versuchen, sie davon zu überzeugen , professionellere Entwickler einzustellen . Auf diese Weise könnten sie sich auf Domainprobleme konzentrieren (ich bin mir sicher, dass sie dort genug haben).

Ich glaube, sie sind sehr kluge Leute, aber ein guter Entwickler zu werden, erfordert viel Zeit. Sind sie bereit, so viel Zeit in einer Tätigkeit zu verbringen, die nicht ihre Hauptaufgabe ist? IMHO ist dies nicht der Weg, um die besten Ergebnisse zu erzielen.

Beeindruckend. Klingt so, als hättest du eine große Herausforderung vor dir! Ich würde etwas in der folgenden Richtung tun:

• Zuallererst: Priorisieren . Was möchten Sie zuerst erreichen? Was ist für den aktuellen Stand des Projekts am wichtigsten? Was werden Sie am meisten nutzen, verglichen mit der Zeit, die Sie brauchen, um dorthin zu gelangen?
• Stellen Sie sicher, dass Sie über ein Versionskontrollsystem verfügen . Git oder Mercurial zum Beispiel.
• Bringen Sie eine Art kontinuierliches Integrationssystem (z. B. Jenkins ) zum Laufen.
• Holen Sie sich ein Bug-Tracking- System zum Laufen. Mantis ist meiner Meinung nach ganz nett.
• Untersuchen Sie die statische Code-Analyse (falls für die Sprache, mit der Sie gerade arbeiten, etwas verfügbar ist).
• Versuchen Sie, so viel Konsistenz wie möglich zu erzielen , von der Benennung von Variablen bis hin zu allgemeinen Codekonventionen und -richtlinien in der Codebasis.
• Testen Sie das System . Dies ist meiner Meinung nach äußerst wichtig für ein großes Altsystem wie dieses. Verwenden Sie Testfälle, um vorhandenes Verhalten zu dokumentieren , unabhängig davon, ob sich das Verhalten seltsam anfühlt oder nicht (normalerweise gibt es einen Grund dafür, warum der Code aus einem bestimmten Grund aussieht, gut oder schlecht sein kann oder beides; P). Michael Feathers Effective Working With Legacy Code ist hierfür eine hervorragende Ressource.

Sie sagen, dass der erste Schritt zur Lösung eines Problems darin besteht, zuzugeben, dass Sie eines haben. In diesem Sinne können Sie zunächst ein Abhängigkeitsdiagramm generieren, das die enorme Verwicklung darstellt, die Ihre aktuelle Codebasis darstellt. Gutes Tool zum Generieren von Abhängigkeitsdiagrammen? ist ein paar Jahre alt, enthält jedoch einige Verweise auf Tools, mit denen solche Grafiken erstellt werden können. Ich würde mit einem großen, hässlichen Graphen arbeiten, der so viel wie möglich anzeigt, um den Punkt nach Hause zu bringen. Sprechen Sie über Probleme, die sich aus zu vielen Abhängigkeiten ergeben, und werfen Sie vielleicht eine Zeile von Buckaroo Banzai ein :

Sie können Ihre Anatomie nach Belieben überprüfen, und auch wenn es zu normalen Abweichungen kommt, sieht alles so weit im Kopf gleich aus. Nein, nein, nein, zieh nicht daran. Man weiß nie, womit es verbunden sein könnte.

Führen Sie von dort aus einen Plan ein, um das Chaos zu beseitigen. Teilen Sie den Code in Module auf, die so eigenständig wie möglich sind. Seien Sie offen für Vorschläge dazu - die Leute, die Sie ansprechen, kennen den Verlauf und die Funktionalität des Codes besser als Sie. Das Ziel ist es jedoch, ein großes Problem in eine Reihe kleinerer Probleme umzuwandeln, die Sie priorisieren und bereinigen können.

Einige Dinge, auf die Sie sich konzentrieren sollten:

• Erstellen Sie saubere Schnittstellen zwischen Modulen und verwenden Sie diese. Möglicherweise wird der alte Code für eine Weile nicht mehr die neuen Schnittstellen verwenden - das ist das Problem, das Sie zu lösen beginnen. Lassen Sie jedoch alle zustimmen, dass nur die neuen Schnittstellen verwendet werden. Wenn etwas benötigt wird, das nicht in den Schnittstellen enthalten ist, korrigieren Sie die Schnittstellen und umgehen Sie sie nicht.

• Suchen Sie nach Fällen, in denen die gleiche Funktionalität wiederholt wurde. Auf die Vereinigung hinarbeiten.

• Erinnern Sie alle von Zeit zu Zeit daran, dass diese Änderungen das Leben erleichtern und nicht erschweren sollen. Übergang kann schmerzhaft sein, aber es hat einen guten Zweck und je mehr alle an Bord sind, desto schneller werden die Vorteile.

Nach einer kurzen Betrachtung von Gensym G2 scheint die Art und Weise, wie dieses Problem angegangen werden kann, stark davon abhängig zu sein, wie viel Code-Basis wie folgt aussieht:

oder dieses:

mit freundlicher Genehmigung von 99 Bottles of Beer :

beer-bottles()

i:integer =99;
j:integer;
constant:integer =-1;

begin
for i=99 down to 1
    do
    j = (i+constant);
        if (i=1) then begin
            post"[i] bottle of beer on the wall";
            post" [i] bottle of beer";
            post" Take one down and pass it around ";
            post" No bottle of beer on the wall"; 
        end 
        else begin
            post"[i] bottles of beer on the wall";
            post" [i] bottles of beer";
            post" Take one down and pass it around ";
            if (i=2) then 
                post" [j] bottle of beer on the wall"
           else
                post" [j] bottles of beer on the wall"; 
           end
    end
end

Im letzteren Fall arbeiten Sie mit Quellcode, der im Grunde genommen eine bekannte Größe ist, und einige der anderen Antworten enthalten sehr gute Ratschläge zum Umgang damit.

Wenn der größte Teil der Codebasis die letztere ist, oder selbst wenn es sich um einen beträchtlichen Teil handelt, stoßen Sie auf das interessante Problem, Code zu haben, der wahrscheinlich nicht überarbeitet werden kann, weil er extrem spezialisiert ist, oder noch schlimmer, etwas, das aussieht es kann entfernbar sein, aber wenn es nicht ordnungsgemäß dokumentiert ist, wissen Sie nicht, ob Sie kritischen Code entfernen (denken Sie an etwas, das im Sinne einer Scram-Operation ist ), das auf den ersten Blick nicht so zu sein scheint.

Obwohl offensichtlich Ihre erste Priorität darin besteht, eine Art Versionskontrolle online zu stellen, wie ElYusubov betonte , und es scheint, dass die Versionskontrolle seit Version 8.3 unterstützt wird . Da es sich bei G2 um eine Kombination verschiedener Sprachmethoden handelt, ist es wahrscheinlich am effektivsten, die mitgelieferte Versionskontrolle zu verwenden, anstatt zu versuchen, etwas anderes zu finden und es zum Laufen zu bringen.

Als nächstes, obwohl einige wahrscheinlich befürworten würden, mit der Umgestaltung zu beginnen, bin ich ein starker Befürworter, sicherzustellen, dass Sie das System, mit dem Sie arbeiten, vollständig verstehen, bevor Sie anfangen, Code zu berühren, insbesondere wenn Sie sich mit Code und visuellen Diagrammen befassen, die von entwickelt wurden Entwickler ohne formale Ausbildung (oder Hintergrund) in Software-Engineering-Methoden. Die Gründe dafür sind vielfältig, aber der offensichtlichste Grund ist, dass Sie mit einer Anwendung arbeiten, in die möglicherweise mehr als 100 Personenjahre Arbeit fließen, und dass Sie wirklich sicherstellen müssen, dass Sie wissen, was sie tut und wie viel Dokumentation gibt es drin. Da Sie nicht gesagt haben, in welcher Branche das System eingesetzt wird, Basierend auf dem, was ich über G2 gelesen habe, ist davon auszugehen, dass es sich wahrscheinlich um eine geschäftskritische Anwendung handelt, die möglicherweise sogar Auswirkungen auf die Lebenssicherheit hat. Daher wird es sehr wichtig sein, genau zu verstehen, was es tut. Es gibt Code, der nicht dokumentiert ist. Arbeiten Sie mit den anderen Teammitgliedern zusammen, um sicherzustellen, dass die Dokumentation vorhanden ist, damit die Benutzer bestimmen können, was der Code tut.

Beginnen Sie als Nächstes mit dem Umschließen von Unit-Tests, um so viele Codebasis- und visuelle Diagramme wie möglich zu erstellen. Ich muss zugeben, dass ich nicht weiß, wie man das mit G2 macht, aber es könnte sich fast lohnen, ein eigenes Test-Framework zu erstellen, um dies umzusetzen. Dies ist auch ein idealer Zeitpunkt, um die anderen Mitglieder des Teams vorzustellen, um sie mit einigen der strengeren Konstruktionspraktiken vertraut zu machen, die mit der Codequalität verbunden sind (dh jeder Code muss über Komponententests und Dokumentation verfügen).

Sobald Sie Unit-Tests für eine angemessene Menge des Codes durchgeführt haben, können Sie sich dem Refactoring auf eine Weise nähern, wie sie Haylem vorgeschlagen hat . Denken Sie jedoch daran, dass Sie es mit etwas zu tun haben, das für die Entwicklung von Expertensystemen und die Umgestaltung gedacht ist. Dies könnte ein harter Kampf sein. Dies ist tatsächlich eine Umgebung, in der etwas gesagt werden muss, um nicht zuweilen extrem generischen Code zu schreiben.

Achten Sie zum Schluss genau darauf, was die anderen Teammitglieder sagen, nur weil die Code- und Diagrammqualität nicht die beste ist, muss dies nicht unbedingt negativ sein. Letztendlich wissen sie vorerst wahrscheinlich mehr über die Funktionsweise der Anwendung als Sie, weshalb es umso wichtiger ist, dass Sie sich hinsetzen und sicherstellen, dass Sie verstehen, was sie tut, bevor Sie ebenfalls umfassende Änderungen vornehmen.

Normalerweise haben die Beschwerden, die Sie im Voraus hören, nichts mit den wichtigen Problemen zu tun. Schließlich ist es völlig normal, dass in Softwareprojekten von diesen Beschwerden die Rede ist.

Schwer zu verstehender Code? Prüfen. Massive Codebasis? Prüfen.

Das eigentliche Problem ist, dass die Leute gehen, und wenn die neue Person der Organisation beitritt, gibt es eine typische Desorientierung. Darüber hinaus gibt es ein Problem mit unrealistischen Erwartungen und Problemen mit der Codequalität.

Hier ist, was ich angehen würde, um:

1. Backups, sowohl der Server als auch die lokale Version
2. Richten Sie den Bug-Tracker ein
3. Richten Sie das Versionsverwaltungssystem ein
4. FAQ / Wiki einrichten
5. Erste Nachbesprechung aller Wissenschaftler / Programmierer
   • Erinnern Sie sie an die 80/20 Regel. 20% der Fehler sind für 80% der Probleme verantwortlich.
   • Konzentrieren Sie sich auf die größten Probleme und lassen Sie Verbesserungswünsche usw. aus.
   • Der Zweck hier ist nicht, Leute mit einer großen Liste zu erschrecken, sondern mit einer Liste von kleinen erreichbaren Gewinnen. Schließlich muss man sich auch bewähren.
6. Richten Sie das Build-System ein
   • Arbeiten Sie daran, zuverlässige Builds zu erhalten (dies kann eine Weile dauern)
   • Jedes Projekt identifizieren und benennen
   • Identifizieren Sie zyklische Abhängigkeiten
   • Wenn es Binärdateien aus Open Source-Projekten gibt, versuchen Sie, Quellen zu beschaffen
7. Identifizieren Sie, wie der G2-Code modularisiert werden kann, z. B. APIs, Services
8. Identifizieren Sie, wie der G2-Code getestet und dokumentiert werden kann.
9. Richten Sie das Code-Review-System ein
10. Zweite Nachbesprechung
    • Wie sieht ein ideales Modul aus?
    • So sperren Sie alten Code ab
    • Wie ein neues Modul um alten Code gewickelt wird (siehe das Strangler-Muster http://agilefromthegroundup.blogspot.com.au/2011/03/strangulation-pattern-of-choice-for.html )
11. Identifizieren Sie ein Crack-Team von besseren Programmierern und arbeiten Sie mit ihnen zusammen, um ihre Module zu verpacken.
12. In dieser Phase sind Codeüberprüfungen vorhanden, um die Kommunikation und Dokumentation zu verbessern. Machen Sie es sich in dieser Phase leicht. Sortieren Sie alle Prozessprobleme.
13. Stellen Sie das System anderen Programmierern zur Verfügung. Lassen Sie die Mitglieder des Crack-Teams zu Peer-Mentoren werden. Denken Sie daran, dass die Skalierung hier das Problem ist. Sie sind effektiv in einer Managementrolle.

Fragen wie diese sind der ganze Grund, warum das Projekt Software Carpentry existiert.

In den letzten 14 Jahren haben wir Wissenschaftlern und Ingenieuren grundlegende Fähigkeiten in der Softwareentwicklung beigebracht: Versionskontrolle, Testen, Modularisieren von Code und so weiter. Alle unsere Materialien sind unter einer Creative Commons-Lizenz frei verfügbar. Wir veranstalten jedes Jahr ein paar Dutzend kostenlose zweitägige Workshops, um den Einstieg zu erleichtern.

Ausgehend davon denke ich, dass der beste Ausgangspunkt wahrscheinlich Robert Glass 'ausgezeichnetes (kurzes) Buch Facts and Fallacies of Software Engineering ist : Sein evidenzbasierter Ansatz ist eine gute Möglichkeit, Wissenschaftler davon zu überzeugen, dass wir ihnen von guten Programmierpraktiken erzählen mehr als nur meinung.
In Bezug auf bestimmte Praktiken sind die beiden, die am ehesten angenommen werden, die Versionskontrolle und das Testen von Einheiten. Sobald diese vorhanden sind, können sie die Art von systematischem Refactoring angehen, die Michael Feathers in Effektiv mit Legacy-Code arbeiten beschreibt .
Ich empfehle The Pragmatic Programmer nicht mehr (viele Ermahnungen, für Anfänger schwer umzusetzen), und ich denke, McConnells Code ist vollständig ist zu viel, um damit zu beginnen (obwohl es eine großartige Sache ist, ihnen sechs Monate oder ein Jahr Zeit zu geben, wenn sie die Grundlagen beherrschen).

Ich kann auch Paul Dubois 'ausgezeichnetes Papier "Aufrechterhaltung der Korrektheit in wissenschaftlichen Programmen" ( Computing in Science & Engineering , Mai-Juni 2005) wärmstens empfehlen , das einen "Defense-in-Depth" -Ansatz beschreibt, der ein Dutzend verschiedener Praktiken in einer logischen, kohärenten Weise kombiniert Weg.

Ich denke zuallererst musst du deine Situation klären. Was wollen sie von dir?

• Es ist sehr unwahrscheinlich, dass Sie eine alte Sprache lernen sollen, da dies jetzt eine Sackgasse zu sein scheint: Es besteht eine geringere Wahrscheinlichkeit, dass jemand G2 kennt oder lernen möchte, sodass das Wissen in dem zusammenbrechenden Haufen Code vergraben wird, wenn Die gegenwärtigen Wissenschaftler gehen oder der vollständig gepatchte Code versagt immer häufiger.
• Sind die Wissenschaftler (oder einige von ihnen) bereit, eine neue Sprache und viele Programmierparadigmen zu lernen? Oder möchten sie die Programmier- und wissenschaftlichen Aktivitäten langfristig trennen und bei Bedarf weitere Programmierer einstellen? Dies scheint eine rationellere und effizientere Trennung von Fachwissen zu sein.

Ich denke, die Kernanforderung hier ist, "das Wissen im System zu speichern", also muss man es ausgraben!

Die erste Aufgabe besteht darin, eine Dokumentation zu schreiben.

Analysieren Sie die Struktur und die Anforderungen so, als wäre dies eine neue Aufgabe, jedoch mit Hilfe eines vorhandenen Systems. Sie werden sich freuen, weil Sie zuerst FRAGEN, anstatt ZU UNTERRICHTEN - und Sie werden schnell genug, aber besser organisiertes Hintergrundwissen aus der Sicht eines Programmierers erhalten: "Was ist hier los?" Die Dokumente (statische Systemstruktur, Arbeitsablauf, Komponenten, Probleme) sind für sie sofort wertvoll und zeigen ihnen möglicherweise relevantere Informationen als Ihnen (einige der Jungs haben möglicherweise "AHA!" Und beginnen sofort, einige Codes zu reparieren ) ...

Sie sollten dann anfangen zu fragen, wohin sie wollen?

Wenn sie bereit sind, sich von G2 zu entfernen, welches System möchten sie sehen (Plattform, Sprache, Oberfläche, allgemeine Struktur)? Möglicherweise schreiben Sie nach Möglichkeit einen externen Wrapper um das System, der die Zielstruktur aufweist, aber die ursprünglichen Komponenten beibehält. Auf diese Weise wird langsam eine Art Framework gestartet, mit dem neue Komponenten in dieser Zielumgebung implementiert werden können. Sie müssen die Kerndienste (persistente Datenverbindungen und "Toolkits": Kernberechnung, Zeichnen, ... Bibliotheken) finden und ihnen eine vertraute Umgebung in einer neuen Plattform und Sprache bereitstellen, die den Übergang entweder von Ihnen oder von Ihnen ermöglicht Sie: Nehmen Sie die alten Codes nacheinander und implementieren Sie sie in der neuen Umgebung neu (und säubern Sie sie!). Wenn das fertig ist, kennen sie die neue Sprache; und die Service-Schicht (die größtenteils von Ihnen erstellt wurde, sorry) ist bereit, die neuen Komponenten zu hosten.

Wenn sie sich nicht bewegen , müssen Sie G2 lernen und dort das modulare Framework erstellen, in das Sie oder sie die Komponenten verschieben sollen (mit Reinigung). Wie auch immer, die Sprache ist nur eine Serialisierung des Daten- und Algorithmusbaums ...

Lesen, verwenden und bewerben Sie beim Analysieren und Schreiben der Dokumente die GoF Design-Muster! :-)

... meine 2 Cent

Ich habe gerade eine Reihe von Präsentationen über die SOLID-Prinzipien von Robert Martin für meine Mitarbeiter durchgeführt. Ich weiß nicht, wie gut sich diese Prinzipien auf G2 übertragen lassen, aber da Sie nach 5-7 Grundprinzipien suchen, scheinen diese zunächst gut etabliert zu sein. Wenn Sie auf 7 aufrunden möchten, können Sie mit DRY beginnen und Fail-Fast einwerfen.

Das einzige Produktionsproblem klingt nach einem Change-Management-Problem. Wenn dies der Fall ist und die Software es auf andere Weise ausführt, ist der erste Rat, den ich geben würde, dem Drang zu widerstehen, zu schnell zu viel zu tun.

Quellcodeverwaltung, Refactoring und besser ausgebildete Entwickler sind alles gute Vorschläge, aber wenn dies das erste Mal ist, dass Sie sich mit dieser Art von Problem befassen müssen, können langsame Bewegungen und kontrollierte Änderungen nicht genug betont werden.

Der Drang, das Chaos zu überwinden, wird manchmal groß sein, aber bis Sie genug davon rückgängig gemacht haben, dass Sie wissen, dass Sie Ihre Ersatzversion angemessen testen können, müssen Sie sehr vorsichtig sein.

Die wichtigsten Grundsätze für das Arbeiten in einer solchen Situation sind:

1. Sei geduldig. Ein Loch, dessen Graben 20 Jahre gedauert hat, wird in ein paar Wochen nicht gefüllt sein.

2. Sei positiv. Widerstehen Sie der Versuchung, sich zu beschweren und zu meckern.

3. Sei pragmatisch. Sehen Sie sich eine positive Veränderung an, die Sie an einem Tag erreichen können, und tun Sie dies heute. Hast du schon ein Versionskontrollsystem? Implementiere es und bilde Leute aus. Dann schauen Sie, ob Sie das Testen automatisieren können (Unit-Testing oder ähnliches). Spülen. Wiederholen.

4. Sei ein Model. Zeigen Sie (nicht nur) den Leuten, wie agil funktioniert, indem Sie agil sind. Die ersten drei Punkte oben sind der Schlüssel zu einem guten Kerl, der der Vorgänger eines effektiven agilen Kerls ist. Meiner Meinung nach sind Leute, die bewundernswerte Entwickler sind, nicht nur schlau, sie sind auch gute, vorbildliche Mitarbeiter und Kollegen.

5. Karten Sie Ihr Territorium. Ich habe eine Technik zum Abbilden von riesigen Legacy-Codebasen. Ich klone das Repo, erstelle eine Arbeitskopie und versuche dann, etwas zu ändern und zu sehen, was sonst noch kaputt geht. Wenn ich die Kopplung untersuche (über einen globalen Status oder defekte APIs oder einen Mangel an konsistenten APIs oder an zu programmierenden Abstraktionen oder Schnittstellen) und den Code lese, der beim Ändern von Dingen kaputt geht, stelle ich Fragen, die dazu führen Einblicke vom Rest des Teams (Oh, wir haben das hinzugefügt, weil Boss X das vor 5 Jahren gefordert hat, es hat nie funktioniert!). Im Laufe der Zeit erhalten Sie eine mentale Karte des Gebiets. Sobald Sie wissen, wie groß es ist, werden Sie genug wissen, um Ihre Karte zu erstellen und nach Hause zu kommen. Ermutigen Sie andere, das Territorium Ihrer riesigen Codebasis abzubilden und das technische Wissen des Teams aufzubauen. Manche Leute scheuen "Dokumentation" weil es nicht agil ist. Wie auch immer. Ich arbeite auch in wissenschaftlichen Umgebungen, und Dokumentation ist für mich das A und O, agile Manifeste.

6. Erstelle kleine Apps. Wenn ich mit einer alten Codebasis arbeite, stelle ich fest, dass ich zu Brei zermahlen werde. Ich bekomme meinen Geist zurück, indem ich kleine Hilfsprogramme baue. Vielleicht helfen Ihnen diese Apps beim Lesen, Verstehen und Ändern dieser riesigen G2-Codebasis. Vielleicht können Sie eine Mini-IDE oder ein Parser-Tool erstellen, mit denen Sie in Ihrer Umgebung arbeiten können. Es gibt viele Fälle, in denen Metaprogrammierung und Toolbuilding Ihnen nicht nur dabei helfen, die riesigen Deadlocks zu überwinden, die Ihnen ältere Codebasen auferlegen, sondern Ihrem Gehirn auch die Fähigkeit geben, uneingeschränkt von Ihrer G2-Sprache zu fliegen. Schreiben Sie Ihre Tools und Helfer in einer beliebigen Sprache, in der Sie sie am schnellsten und besten ausführen können. Zu diesen Sprachen gehören für mich Python und Delphi. Wenn Sie ein Perl-Typ sind oder in C ++ oder C # programmieren möchten, schreiben Sie Ihre Hilfsprogramme in dieser Sprache.

1. Revisionskontrolle : Zeigen Sie den Domain-Experten den Vorteil, dass Sie zurücksetzen können, sehen können, wer was geändert hat usw. (Dies ist bei rein binären Dateien schwieriger, aber wenn der Inhalt tatsächlich Code ist, gibt es mit Sicherheit eine Art von G2-to-G2.) Textkonverter, der Unterschiede aktivieren kann.)

2. Kontinuierliche Integration und Test : Lassen Sie die Domain-Experten an der Erstellung von End-to-End-Tests (einfacher, da sie bereits Eingaben und erwartete Ausgaben irgendwo haben müssen) und kleinen Unit-Tests (schwieriger, weil Spaghetti-Code wahrscheinlich viele globale Variablen enthält) mitwirken decken nahezu alle Funktionen und Anwendungsfälle ab.

3. Konvertieren Sie allgemeinen Code in wiederverwendbare Routinen und Komponenten. Nicht-Software-Anwender ohne Revisionskontrolle kopieren wahrscheinlich Hunderte von Zeilen gleichzeitig und fügen sie ein, um Routinen zu erstellen. Finden Sie sie und überarbeiten Sie sie, um zu zeigen, dass alle Tests bestanden wurden und der Code kürzer geworden ist. Dies wird Ihnen auch helfen, die Architektur zu erlernen. Wenn Sie Glück haben, wenn Sie anfangen müssen, die schwierigen architektonischen Entscheidungen zu treffen, sind Sie möglicherweise auf 100KLOC gesunken.

Politisch , wenn Sie einen Widerstand aus den alten Zeiten in diesem Prozess finden, mieten Sie einen Berater kommen und einen Vortrag über gute Software Methodik zu geben. Stellen Sie sicher, dass Sie eine gute Person finden, deren Ansichten Sie zustimmen, und veranlassen Sie das Management, die Notwendigkeit des Beraters in Kauf zu nehmen, auch wenn die Domain-Experten dies nicht tun. (Sie sollten sich einig sein - schließlich haben sie Sie engagiert, sodass sie offensichtlich erkennen, dass sie Software-Engineering-Fachkenntnisse benötigen.) Dies ist natürlich ein geldverschwenderischer Trick, aber der Grund dafür ist, dass Sie - der neue heiße junge Programmierer - davon erzählen Wenn sie etwas tun müssen, können sie es ignorieren. Aber wenn das Management einem Berater 5.000 US-Dollar bezahlt, um ihm zu sagen, was er tun muss, wird er mehr Vertrauen in ihn setzen. Bonuspunkte: Lassen Sie den Berater doppelt so viele Änderungen empfehlen, wie Sie wirklich möchten. Dann können Sie der "Gute" sein und mit den Domain-Experten zusammenarbeiten, ohne Kompromisse eingehen und nur die Hälfte der vom Berater vorgeschlagenen Änderungen vornehmen zu müssen.

"Das Programm selbst ist ein physikalisches Modell einer komplexen chemischen Aufbereitungsanlage ..."

"Da G2 nicht wie Code ist, sondern wie automatisierter Code, der von einer hinreißenden GUI geschrieben wurde ..." - Erik Reppen

Angenommen, das Hauptziel Ihrer Software besteht darin, eine komplexe Chemiefabrik oder Teile davon zu simulieren (vielleicht zu optimieren, Parameterschätzungen durchzuführen) ... dann möchte ich einen etwas anderen Vorschlag machen:

Sie sollten in Betracht ziehen, eine mathematische Modellierungssprache auf hoher Ebene zu verwenden, um die Essenz, die wichtigsten mathematischen Modelle, aus handcodierter Software zu extrahieren .

Eine Modellierungssprache entkoppelt die Beschreibung des Problems von den zur Lösung des Problems verwendeten Algorithmen. Diese Algorithmen sind im Allgemeinen auf die meisten Simulationen / Optimierungen einer bestimmten Klasse (z. B. chemische Prozesse) anwendbar. In diesem Fall sollten sie nicht neu erfunden und intern gewartet werden.

Drei kommerzielle Pakete, die in Ihrer Branche häufig verwendet werden, sind: gPROMS, Aspen Custom Modeller und (falls Ihre Modelle keine Phänomene enthalten, die über räumliche Domänen verteilt sind) Modelica-basierte Softwarepakete wie Dymola.

Alle diese Pakete unterstützen auf die eine oder andere Weise "Erweiterungen". Wenn Sie also Teile Ihrer Modelle haben, die eine benutzerdefinierte Programmierung erfordern, können diese in ein Objekt (z. B. eine .DLL) eingekapselt werden, auf das durch die Gleichungen in der verwiesen wird Modell. Währenddessen bleibt der Großteil Ihres Modells prägnant und wird in einer Form beschrieben, die von den Wissenschaftlern direkt gelesen werden kann. Dies ist eine viel bessere Möglichkeit, das Wissen und die geistige Eigentumsrechte Ihres Unternehmens zu erfassen.

Die meisten dieser Programme sollten es Ihnen auch ermöglichen, kleine Teile (Untermodelle) Ihres monolithischen Codes durch externen Aufruf in ihr Format zu portieren. Dies kann eine gute Möglichkeit sein, ein funktionierendes System zu warten und es einzeln zu validieren.

Voller Haftungsausschluss: Ich habe 8 Jahre als Software-Ingenieur bei der Firma hinter gPROMS gearbeitet. In dieser Zeit habe ich Beispiele von kundenspezifischer Software (z. B. aus dem akademischen Bereich) gesehen (und gelegentlich aufgenommen), die klein und ordentlich angefangen hatte, eine clevere Lösung oder einen Algorithmus implementiert und dann im Laufe der Jahre mit Erweiterungen und Modifikationen explodiert war - ohne die hilfreiche Anleitung von ein Software-Ingenieur, um es sauber zu halten. (Ich bin ein großer Fan von multidisziplinären Teams.)

Daher kann ich mit einiger Erfahrung sagen, dass bestimmte Schlüsselentscheidungen, die zu Beginn einer Software-Entwicklung schlecht getroffen wurden (wie eine Sprache oder eine Schlüsselbibliothek), dazu neigen, lange Zeit zu verharren und Schmerzen zu verursachen ... Sie haben die Software bereits "geformt" Software um sie herum. Es hört sich für mich so an, als ob Sie hier vor einer jahrelangen Bereinigung von reinem Code stehen könnten. (Ich zögere, Zahlen zu verwenden, denke aber über 10 Jahre, vielleicht sogar noch viel mehr, wenn Sie den Code nicht von G2 auf etwas portieren können, das gute automatisierte Refactoring-Tools wie Eclipse / Java quick-smart unterstützt.)

Während mein Standardstatus "Refactor und Beibehalten eines funktionierenden Systems" ist, denke ich auch, dass ein radikaleres Ändern / Umschreiben insgesamt schneller wird, sobald ein Problem "zu groß" wird. (Und bringt möglicherweise zusätzliche Vorteile mit sich, z. B. das Wechseln zu einer moderneren Technologie.) Ich sage, dass die Portierung auf eine neue Softwareplattform mit etwas Erfahrung noch dramatischer ist, wenn man eine Portierung auf ein mathematisches Modellierungspaket vornimmt.

Um Ihnen eine Perspektive zu geben, werden Sie vielleicht erstaunt sein, wie groß die Verkleinerung ist. ZB könnten die 200.000 LoC tatsächlich in so etwas wie 5.000 Gleichungszeilen dargestellt werden (OK, ich vermute hier, aber ich könnte versuchen, Ihnen ein tatsächliches Zeugnis von Freunden im Geschäft zu geben). Dazu kommen ein paar relativ kleine Funktionsmodule, die in so etwas wie C geschrieben sind (z. B. Berechnungen der physikalischen Eigenschaften - obwohl je nach chemischem Prozess möglicherweise auch Pakete von der Stange sind). Dies liegt daran, dass Sie den algorithmischen Lösungscode buchstäblich einfach wegwerfen und einen Allzweck-Stapel mathematischer Löser die harte Arbeit erledigen lassen. Sobald Sie Simulationen ausgeführt haben, können Sie viel mehr damit tun, beispielsweise den Prozess optimieren, ohne eine Codezeile zu ändern.

Abschließend möchte ich sagen: Wenn die einzige zuverlässige Dokumentation der verschiedenen mathematischen Modelle (und Algorithmen) der Code selbst ist, möchten Sie die Hilfe der Wissenschaftler und Originalautoren, um diese Modelle schnellstmöglich zu extrahieren, und nicht Jahre später Einige von ihnen sind vielleicht weitergezogen. Sie sollten feststellen, dass eine mathematische Modellierungssprache ein sehr natürlicher Weg ist, um diese Modelle zu erfassen - sie können sogar (Schock-Horror) Spaß daran haben, sie (neu) zu schreiben.

Da meine Antwort möglicherweise falsch ist, möchte ich der Liste der guten Bücher, auf die hier bereits verwiesen wurde, nur ein weiteres Buch hinzufügen: Clean Code von Robert Martin. Voller einfacher (und gerechtfertigter) Tipps, die leicht zu erlernen und anzuwenden sind, die jedoch für die Menschen, die in Ihrem Unternehmen neuen Code entwickeln, einen großen Unterschied bedeuten können.

Ich würde folgendes runterwerfen:

1. Hier ist ein Programmierer. Scheiß auf Politik. Sie kennen ihren Beruf. Du kennst deins. Markieren Sie dieses Gebiet, auch wenn Sie darauf pissen müssen. Sie sind Wissenschaftler. Sie können solche Dinge respektieren oder sollten dies tun, da sie selbst so ziemlich ständig dasselbe tun. Markieren Sie jetzt mit allen Mitteln die Grenzen. Das werde ich reparieren. Dafür kann ich nicht verantwortlich sein.

2. Wissenschaftler schreiben / testen die Algorithmen. Wissenschaftler, die ihre eigenen Algorithmen in 1-3 Sprachen schreiben möchten, können sich darauf einigen, dass Sie in Kerncode konvertieren. Das bringt es mit sich, ihre Sachen auf die Probe zu stellen. Darüber hinaus werden sie Ihnen helfen müssen, die wichtigen wissenschaftlichen Dinge zu isolieren, im Vergleich zu dem, was sie für die Architektur getan haben. Die Codebasis ist abgespritzt. Es gibt viele Brandrodungen, die erledigt werden müssen. Geben Sie ihnen die Möglichkeit, Ihnen Arbeitsversionen von Dingen zu übergeben, die das verwenden, was sie am besten wissen, damit Sie das tun können, was Sie am besten können. Stecke ihr Wissen in eine Kiste, für die sie verantwortlich sind, mit der du aber arbeiten kannst.

3. Verwenden Sie eine ereignisgesteuerte Sprache mit erstklassigen Funktionen, wenn Sie können. Wenn alles andere fehlschlägt, kann es eine enorme Zeitersparnis bedeuten, ein Ereignis auszulösen oder einen Rückruf auf ein Objekt mit einer tatsächlich sinnvollen Schnittstelle und einem sinnvollen Statusmechanismus zu werfen, wenn Sie sich in knietiefem Code befinden, der keinen blutigen Sinn ergibt und möglicherweise nie werden. Wissenschaftler scheinen Python zu mögen. Es ist nicht schwer, C-Zeug mit geringerer Mathematikintensität damit zu verkleben. Ich sag bloß'

4. Suchen Sie jemanden, der dieses oder ein ähnliches Problem gelöst hat. Verbringen Sie einige Zeit mit Nachforschungen. Diese Leute haben von jemandem von G2 gehört.

5. Designmuster. Adapter. Benutze sie. Benutze sie oft in solchen Situationen.

6. Erfahren Sie, was Sie von der Wissenschaft können. Je mehr Sie wissen, desto besser können Sie die Absicht im Code bestimmen.

Führen Sie zuerst die Analyse durch.

Ich würde einige Analysen machen, bevor ich mich entscheide, was ich unterrichten soll. Finden Sie heraus, wo die größten Probleme liegen. Verwenden Sie diese, um zu priorisieren, welche Praktiken zu übergehen sind.

Nehmen Sie jeweils nur wenige Änderungen vor (in einer ähnlichen Situation habe ich alle 2 Wochen 2-3 Übungen durchgeführt) .

Ich würde die Praktiken auf ~ 3 beschränken, abhängig vom Grad der Änderung des SDLC-Programmierstils. bis sie anfangen, sich mit ihnen vertraut zu machen (ich würde mich bemühen, alle 1-2 Wochen eine neue Änderung einzuführen, wenn sie sich mit der Idee vertraut machen, neue Ansätze zu erlernen). Es ist auch eine gute Idee, das Erfolgskriterium zu ermitteln. Was die Praxis erreichen sollte (auch wenn es ein weiches Ziel wie die Moral des Teams ist). Auf diese Weise können Sie zeigen, ob es effektiv ist oder nicht.

• Warum die Anzahl der Änderungen begrenzen?

Auch wenn Sie davon ausgehen, dass diese Leute bessere Programmierer sein möchten und offen für das Lernen sind, gibt es Grenzen dafür, wie viel und wie schnell Menschen neue Konzepte lernen und diese anwenden können. vor allem, wenn sie keine CS-Grundlage haben oder zuvor an einem Software Development Life Cycle teilgenommen haben.

Fügen Sie eine wöchentliche Abschlussbesprechung hinzu, um zu besprechen, wie sich die Praktiken auf sie ausgewirkt haben.

Das Treffen sollte genutzt werden, um zu besprechen, was gut gelaufen ist und was Arbeit braucht. Erlauben Sie ihnen, eine Stimme zu haben und kooperativ zu sein. Diskutieren und planen Sie, um Probleme anzugehen und die nächsten anstehenden Änderungen in der Vorschau anzuzeigen. Konzentrieren Sie sich auf die Praktiken und deren Anwendung. Machen Sie eine kleine Evangelisierung über die Vorteile, die sie aus der Anwendung der Praktiken ziehen sollten.

Bestimmte Praktiken haben Vorrang.

Die ordnungsgemäße Verwendung eines Versionskontrollsystems (IMO) übertrifft alles andere. Gleich dahinter folgen Lektionen in Modularisierung, Kopplung / Kohäsion und Feature / Bug-Ticket-Tracking.

Entfernen Sie Praktiken, die nicht funktionieren.

Hab keine Angst, Praktiken loszuwerden, die nicht funktionieren. Wenn es hohe Kosten und wenig bis keinen Nutzen gibt, entfernen Sie die Praxis.

Verbesserung ist ein Prozess.

Vermitteln Sie, dass eine nachhaltige, konsequente Verbesserung ein Prozess ist. Identifizieren Sie die größten Schwachstellen, wenden Sie eine Lösung an, warten Sie / trainieren Sie und wiederholen Sie dann. Es wird sich anfänglich quälend langsam anfühlen, bis Sie etwas Schwung aufbauen. Konzentrieren Sie sich stets auf die kommenden und bereits erfolgreichen Verbesserungen.

Der erste Schritt, den Sie tun müssen, ist, dem Team die Notwendigkeit zu verkaufen, in neue Softwaremethoden zu investieren. Laut Ihrer Aussage gibt es keine Übereinstimmung im Team, und Sie müssen in der Lage sein, ein langsames "Upgrade" des Codes voranzutreiben.

Ich würde (wenn ich kann) persönlich die harten Lehren ziehen und jedes der Schlüsselkonzepte, die Sie wollen, als Lösung für das Problem in der Softwareindustrie vorstellen.

ZB hatten zwei Entwickler unterschiedliche Kopien und stellten eine hybride, nicht getestete Version bereit -> Führen Sie Versionskontrolle, Verzweigung und Testen ein.

Jemand hat ein paar Codezeilen entfernt, die er nicht verstand, und einen Ausfall verursacht -> DDD einführen.

Wenn die harten Lektionen nicht detailliert genug mit Ihnen geteilt werden, zeigen Sie einfach Ihre eigenen Beispiele, wie die Dinge schief gelaufen sind, als diese Disziplin nicht eingehalten wurde.

Die Quellcodeverwaltung ist Schritt 1, wie bereits oft angegeben. Während die Leute, mit denen Sie zusammenarbeiten, möglicherweise keine professionellen Entwickler sind und nicht auf viele Unternehmens- oder agile Mumbo-Jumbos reagieren. Sie sind auch keine niederen Code-Affen, und der Versuch, sie so zu behandeln, indem man sie dazu zwingt, Dinge zu tun, die auf Ihre Art und Weise geschehen, wird nicht fliegen.

Sie müssen überblicken, was da draußen ist. Wenn sie keine Quellcodeverwaltung verwendet haben, wird es lange dauern, nur die richtigen Versionen des Codes zu identifizieren (falls möglich) und alle möglichen Ergebnisse zu ermitteln. Dann haben Sie die Aufgabe, Ihren Kollegen den Umgang mit der Quellcodeverwaltung beizubringen und sie davon zu überzeugen, dass sich die Zeit lohnt. Beginnen Sie mit den Vorteilen!

Finden Sie dabei andere niedrig hängende Früchte und beheben Sie diese Probleme.

Hören Sie vor allem zu, was sie zu sagen haben, und arbeiten Sie daran, ihre Situation zu verbessern. Mach dir keine Sorgen, wenn du versuchst, deinen Stempel aufzudrücken.

Viel Glück!