Für welche OOP-Codierungspraktiken sollten Sie sich immer Zeit nehmen?

https://stackoverflow.com/questions/314241

10-07-2019
|

Frage

Ich neige dazu, viele Projekte mit kurzen Fristen und mit viel Code durchzuführen, der nie wieder verwendet wird. Daher besteht immer der Druck bzw. die Versuchung, Abstriche zu machen.Eine Regel, an die ich mich immer halte, ist Kapselung/lose Kopplung, daher habe ich viele kleine Klassen statt einer riesigen Gottklasse.Aber worauf sollte ich sonst keine Kompromisse eingehen?

Aktualisieren - Danke für die tolle Antwort.Viele Leute haben Unit-Tests vorgeschlagen, aber ich glaube nicht, dass das für die Art der UI-Codierung, die ich mache, wirklich angemessen ist.Usability-/Benutzerakzeptanztests scheinen sehr wichtig zu sein.Um es noch einmal zu betonen: Ich spreche vom absoluten Minimum an Codierungsstandards für unmögliche Deadline-Projekte.

Lösung

Nicht OOP, sondern eine Praxis, die sowohl kurz- als auch langfristig hilft, ist DRY, Do not Repeat Yourself. Nicht copy / paste Vererbung.

Andere Tipps

Nicht eine OOP Praxis, aber der gesunde Menschenverstand, -).

Wenn Sie in Eile sind, und müssen einen Hack schreiben. Immer ein Stück Kommentar mit den Gründen hinzuzufügen. So können Sie es zurück verfolgen und eine gute Lösung später machen.

Wenn Sie nie die Zeit, wieder zu kommen haben, haben Sie immer den Kommentar, so dass Sie wissen, warum die Lösung im Moment gewählt wurde.

Verwenden Sie Quellcodeverwaltung .

Egal, wie lange es dauert, einzurichten (Sekunden ..), es wird immer das Leben einfacher machen! (Es ist immer noch nicht OOP verwandt).

Naming. Unter dem Druck werden Sie schrecklich Code schreiben, dass Sie keine Zeit Kommentar zu dokumentieren oder sogar haben. Benennen von Variablen, Methoden und Klassen explizit wie möglich dauert fast keine zusätzliche Zeit und wird das Chaos lesbar machen, wenn man es beheben müssen. Von einer OOP Sicht Substantive für Klassen und Verben für Methoden hilft natürlich, Einkapselung und Modularität.

Unit-Tests - helfen Sie, in der Nacht schlafen: -)

Das ist ziemlich offensichtlich (hoffe ich), aber zumindest habe ich immer meine öffentliche Schnittstelle stellen Sie sicher, möglichst korrekt ist. Die Interna einer Klasse kann immer später Refactoring werden.

keine öffentliche Klasse mit wandelbaren öffentlichen Variablen (struct-like).

Bevor Sie es kennen, Sie zu dieser öffentlichen Variable verweisen überall auf Ihren Code, und der Tag dieses Feld entscheiden, ist eine berechnete ein und muss eine gewisse Logik darin haben ... das Refactoring wird chaotisch.

Wenn der Tag vor dem Release-Datum ist, wird es chaotischer.

über die Menschen denken (vielleicht sogar Ihre Zukunft selbst sein), der lesen und den Code an einem bestimmten Punkt zu verstehen.

Die Anwendung der einzelnen Verantwortung Haupt. Effektiv dieses Prinzip Anwendung viele positive externe Effekte erzeugt.

Wie alle anderen, nicht so viel OOP Praktiken, so viel wie Praktiken für die Codierung, die OOP gelten.

Unit-Test, Unit-Test, Unit-Test. Definierte Komponententests haben eine Gewohnheit der Menschen auf Aufgabe zu halten und nicht „wandernde“ Ziellos zwischen Objekten.
definieren und dokumentieren alle hierarchischen Informationen (Namespaces, die Pakete, Ordnerstrukturen, etc.) vor Produktionscode zu schreiben. Dies hilft, Objektbeziehungen Fleisch aus und setzen Fehler in den Annahmen zu Beziehungen von Objekten zusammen.
definieren und dokumentieren alle anwendbaren Schnittstellen vor Produktionscode zu schreiben. Wenn durch eine Leitung oder einen Architekten gemacht, kann diese Praxis zusätzlich helfen, mehr Junior-Level-Entwickler auf Aufgabe.

Es gibt wahrscheinlich unzählige andere „sollte“, aber wenn ich meine Top drei holen, das wäre der Liste sein.

Edit als Antwort auf Kommentar: Das ist genau, warum Sie diese Dinge nach vorne zu tun. Alle diese Arten von Praktiken machen Fortsetzung Wartung einfacher. Wie Sie mehr Risiko in dem Kick-off eines Projektes ist, desto wahrscheinlicher ist es, dass übernehmen Sie den Code immer mehr Zeit aufrechterhalten werden verbringen. Zugegeben, es ist ein größer Kosten im Voraus, sondern zahlt sich auf einem solides Fundament aufzubauen. Ist Ihr Hindernis Mangel an Zeit (das heißt mit anderen Anwendungen zu erhalten) oder eine Entscheidung von höher? Ich hatte diese Art von Praktiken zu übernehmen diesen beiden Fronten kämpfen zu können, und es ist keine angenehme Situation sein.

Natürlich sollte alle Einheit getestet werden, gut gestaltet, kommentiert, geprüft in der Quellcodeverwaltung und frei von Fehlern. Aber das Leben ist nicht so.

Mein persönliches Ranking, ist dies:

Verwenden Sie die Quellcodeverwaltung und eigentlich schreiben Kommentare begehen. Auf diese Weise haben Sie ein kleines bisschen Dokumentation sollten Sie sich je gefragt, „was zum Teufel dachte ich, als ich das geschrieben?“
Schreiben Sie sauberen Code oder Dokument. Saubere gut geschriebener Code sollte wenig Dokumentation benötigen, wie es Bedeutung ist aus der Lektüre erfasst werden. Hacks sind ganz anders. Schreiben Sie, warum haben Sie es, was Sie tun und was Sie möchten, dass tun, wenn Sie die Zeit / Wissen / Motivation hatte / ... es richtig
Unit Test. Ja, es ist nach unten auf die Nummer drei. Nicht, weil es unwichtig, sondern weil es nutzlos ist, wenn Sie nicht über die anderen beiden mindestens zur Hälfte abgeschlossen. Schreiben Unit-Tests wird eine weitere Ebene der Dokumentation, was Sie Code sollte (unter anderem) tun.
Umgestalten, bevor Sie etwas hinzufügen. Dies könnte wie ein typischer Sound „aber wir haben keine Zeit für sie“ Punkt. Aber wie bei vielen dieser Punkte es spart in der Regel mehr Zeit, als es kostet. Zumindest wenn man zumindest einige Erfahrung damit haben.

Ich bin mir bewusst, dass ein großer Teil davon ist bereits erwähnt worden, aber da es sich um eine eher subjektive Angelegenheit ist, wollte ich mein Ranking hinzuzufügen.

[insert vorformulierten nicht-OOP spezifische Einschränkung hier]

Die Trennung von Bedenken, Unit-Tests, und das Gefühl, dass, wenn etwas zu komplex ist, ist es wahrscheinlich nicht ganz richtig noch konzeptualisiert.
UML skizzieren: dies hat klargestellt und gespeichert jede Menge vergebliche Mühe, so viele Male. Die Bilder sind groß sind, nicht wahr? :)
Wirklich über is-a denkt und hat-a ist. dieses beim ersten Mal richtig zu bekommen ist so wichtig.

Egal wie schnell ein Unternehmen will es, ich versuche so ziemlich immer Code zu den besten meiner Fähigkeit zu schreiben.

Ich finde nicht, es dauert länger und in der Regel viel Zeit spart, auch in der kurzfristigen.

Ich habe nicht immer das Schreiben von Code erinnern kann und nie Blick auf sie wieder, habe ich immer ein paar Pässe über sie machen es zu testen und zu debuggen, und sogar in den wenigen Pässe Praktiken wie Refactoring meinen Code trocken zu halten, Dokumentation (bis zu einem gewissen Grad), Trennung von Bedenken und Zusammenhalt scheint alle Zeit zu sparen.

Dazu gehören viele kleine Klassen, als die meisten Menschen Kistenverpackungen (Eine Sorge pro Klasse, bitte) und oft Initialisierungsdaten in externe Dateien (oder Arrays) Extrahieren und wenig Parser für diese Daten zu schreiben ... Manchmal sogar wenig GUIs zu schreiben statt Editieren von Daten von Hand.

selbst Codierung ist ziemlich schnell und einfach, Mist jemand Debuggen schrieb, wenn sie „unter Druck“ waren ist das, was die ganze Zeit in Anspruch nimmt!

Bei fast einem Jahr in mein aktuelles Projekt, das ich endlich ein automatisiertes Build einrichten, die alle neue Commits auf den Testserver schiebt, und einen Mann, ich wünsche ich, dass man am Tag getan hatte. Der größte Fehler, den ich früh auf gemacht war gehen dunkel . Mit jeder Funktion, Erweiterung, Bug-Fix etc, hatte ich einen schlimmen Fall von dem „nur ein mores“, bevor ich jemand das Produkt sehen lassen würde, und es buchstäblich in einen 6 Monate Zyklus schraubte. Wenn jeder vernünftige Änderung härter hätte es hätte gewesen automatisch herausgeschoben für mich zu verstecken, und ich möchte die Beteiligung der Akteure mehr auf der Strecke in Bezug haben.

Code Zurück schreiben Sie ein paar Tage / Wochen und verbringen 20 Minuten Ihren eigenen Code zu überprüfen. Im Laufe der Zeit werden Sie in der Lage sein, zu bestimmen, ob Ihr „off-the-Manschette“ Code gut genug organisiert ist für zukünftigen Wartungsaufwand. Während Sie dort sind, nach Möglichkeiten suchen, Refactoring und Umbenennung.

ich manchmal feststellen, dass der Name, den ich für eine Funktion zu Beginn wählte perfekt nicht die Funktion in seiner endgültigen Form passen. Mit Refactoring-Tool können Sie ganz einfach den Namen früh ändern, bevor es in weit verbreiteten Einsatz geht.

Wie alle anderen bereits angedeutet haben, beziehen sich diese Empfehlungen nicht speziell auf OOP:

Stellen Sie sicher, dass Sie Ihren Code kommentieren und sinnvoll benannte Variablen verwenden.Wenn Sie jemals auf den Quick-and-Dirty-Code zurückblicken müssen, den Sie geschrieben haben, sollten Sie ihn leicht verstehen können.Eine allgemeine Regel, die ich befolge, ist:Wenn Sie den gesamten Code gelöscht haben und nur noch die Kommentare übrig haben, sollten Sie den Programmablauf immer noch verstehen können.

Hacks sind in der Regel kompliziert und nicht intuitiv, daher sind gute Kommentare unerlässlich.

Wenn Sie normalerweise unter engen Zeitvorgaben arbeiten müssen, würde ich Ihnen außerdem empfehlen, sich eine Codebibliothek zuzulegen, die auf Ihren häufigsten Aufgaben basiert.Auf diese Weise können Sie „die Punkte verbinden“, anstatt das Rad jedes Mal neu zu erfinden, wenn Sie ein Projekt haben.

Grüße,

Dokta

Eine tatsächliche OOP Praxis habe ich immer Zeit für die Single Prinzip Verantwortung , weil es so viel schwieriger wird, um richtig den Code Refactoring später, wenn das Projekt ist „live“.
Mit dem Festhalten an dieses Prinzip finde ich, dass der Code, den ich schreiben ist leicht wiederverwendet werden, ersetzt oder neu geschrieben, wenn sie die funktionellen oder nicht-funktionale Anforderungen entsprechen nicht. Wenn Sie mit Klassen am Ende, die mehrere Aufgaben haben, können einige von ihnen die Anforderungen erfüllen, einige können nicht, und das Ganze völlig unklar sein kann.
Diese Arten von Klassen sind stressig zu halten, weil man nie sicher ist, was Ihre „reparieren“ brechen.

Für diesen Sonderfall (kurze Fristen und mit viel Code, der wird nie wieder verwendet werden) Ich schlage vor, Sie die Aufmerksamkeit auf die Einbettung einige Script-Engine in die OOP Code zu zahlen.

Erfahren Sie auf "refactor as-you-go". In erster Linie aus einem „extract method“ Standpunkt aus. Wenn Sie beginnen, um einen Block von sequentiellem Code zu schreiben, ein paar Sekunden dauern, um zu entscheiden, ob dieser Block als wiederverwendbare Methode allein stehen kann, und wenn ja, diese Methode sofort machen. Ich empfehle es auch für Wegwerf-Projekte (vor allem, wenn Sie später wieder gehen können, und solche Verfahren in Ihre persönliche Toolbox API kompilieren). Es dauert nicht lange dauern, bevor Sie es tun, fast ohne zu denken.

Hoffentlich tun Sie dies bereits und ich in den Chor bin predigen.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow