Sollte ich einfache Korrekturen protokollieren?

Ich bin in einem Code-Shop von zwei. Und obwohl ich verstehe, dass ein Bug-Tracker nützlich ist, wenn die Anzahl der Programmierer größer oder gleich eins ist, bin ich nicht so überzeugt, dass das Protokollieren von Fehlern, Änderungen und Korrekturen die Zeit wert ist, wenn sie unbedeutend sind. Wenn ich einen einfachen Fehler finde, verstehe ich ihn, behebe ihn und führe einige Tests durch. Und dann wurde mir klar, dass ich es aufzeichnen muss.

Ich weiß in der Theorie, dass die Fehlerprotokollierung irgendwo zwischen dem Auffinden des Fehlers und dem Beheben des Fehlers durchgeführt werden sollte, aber wenn das Beheben schneller ist als das Protokollieren, scheint es ein Problem zu sein. In größeren Code-Shops achtet der Chef darauf, wer was macht, und es ist schön zu wissen, wo andere herumalbern.

Ich beschreibe Dinge, die ich bereits behoben habe, und schließe sie dann sofort ab. Ich habe Zweifel, dass sich irgendjemand diesen geschlossenen Bug noch einmal ansehen wird. Ist es Zeit, das Prozessfett zu reduzieren?

Sie sollten jede Änderung, die Sie an Ihrem System vornehmen, protokollieren. Es ist nichts Falsches daran, es nach dem Ereignis zu protokollieren - solange Sie den Fehlerbericht mit der Änderungsnummer verknüpfen.

Wenn dann jemals etwas schief geht, können Sie den Fehler nachverfolgen und herausfinden, warum Sie die vorgenommene Änderung vorgenommen haben.

In den allermeisten Fällen haben Sie Recht und niemand wird sich diese jemals wieder ansehen, aber im 1 von 100 Fällen, in denen etwas schief geht, sind diese Informationen von unschätzbarem Wert - insbesondere, wenn das Problem erst 6 Monate später auftritt.

AKTUALISIEREN

Wenn Sie noch eine neue Funktion entwickeln und einen Fehler in einem Teil der Funktion entdecken, von dem Sie dachten, dass Sie damit fertig sind, ist es offensichtlich nicht erforderlich, ihn als separate Änderung zu protokollieren. In diesen Fällen würde ich es gegen das Element protokollieren, das die Hauptfunktion anfordert.

Sobald das System mit dem Merkmal hat QA oder den Kunden weitergegeben worden ist , dann ist es notwendig , zu tun , was ich oben beschrieben.

Wenn Sie ein Versionsverwaltungs-Tool verwenden, können Sie den Fehler, den Sie in der Commit-Beschreibung behoben haben, beschreiben. Dies ist normalerweise eine ausreichende Dokumentation für sehr kleine, triviale Fehlerbehebungen.

Wenn Sie einen Bug- / Feature-Tracker verwenden, der vollständig in Ihre Quellcodeverwaltung und Repositorys integriert ist, wie z. B. FogBugz und Kiln , können Sie mit der globalen Suche nach diesen Bugfixes suchen und feststellen, welche Codeänderungen Sie vorgenommen haben leicht.

Außerdem können Sie Ihrem Programmierpartner eine Codeüberprüfung zuweisen, damit er die von Ihnen vorgenommene triviale Korrektur überprüfen kann, aber ich schweife ab ...

Aus metrischer Sicht kann es durchaus noch nützlich sein.

Diese Informationen könnten verwendet werden, um dem Chef eine Reihe von Dingen zu zeigen:

• Wir brauchen mehr Entwickler
• Etwas anderes im Prozess ist kaputt (warum so viele Bugs? Erzeugt der andere Typ die meisten Bugs), was vielleicht anzeigt, dass Sie zu viele Bugs haben. Vielleicht hat etwas damit zu tun? Entlassen Sie zu früh? Wird genug getestet?
• Eine gute Liste von dem, woran Sie gearbeitet haben, gibt es in der Bonuszeit.

Das alles hängt davon ab, wie klein der Fehler ist, von dem Sie sprechen. Ein Liner, den Sie zufällig beim Hinzufügen von neuem Code entdecken, wäre wahrscheinlich sinnlos, um ihn beispielsweise zu protokollieren.

Ich versuche, jede Änderung, die ich vornehme, unabhängig von der Größe zu protokollieren. Sie wissen nie, wann Sie oder jemand anderes (zukünftig oder gegenwärtig) zurückgehen müssen, um zu sehen, ob diese Änderung die mögliche Ursache für etwas anderes ist.

Tracking ist wichtig, aber denken Sie auch an ein anderes Szenario: Wenn es Zeit für Ihre Überprüfung ist. Es wird formell persönlich oder informell geschehen, ohne dass Sie dort über Ihren Chef Berichte aus dem Bug-Tracker abrufen.

Betrachten Sie sie als "Gimmes", die Ihre Zahlen steigern. Schließlich handelt es sich um Fehler, die Sie behoben haben, und Sie sollten für die Behebung von Fehlern erkannt werden, auch wenn es sich um geringfügige Korrekturen handelt.

Log sie.

Um dies zu beantworten, kommt es wirklich darauf an, wo Sie sich gerade befinden.

Diese können für ein neues Projekt oder einen neuen Funktionssatz gelten, der entworfen wird.

Anfängliches Design Wenn Sie Fehler in Code finden, den wir während des anfänglichen Designs erstellt haben, ist es nicht erforderlich, eine Fehlerspur dafür zu erstellen. Ich würde ein separates Commit für die Änderung vorschlagen, damit Sie es problemlos rückgängig machen können, wenn Sie später ein Problem finden.

Testen

Code wird beim Unit-Test normalerweise immer noch als unreif eingestuft. Wenn er nicht von einer anderen Gruppe ausgeführt wird, würde ich nein sagen. Wenn Unit-Tests von einer anderen Gruppe als einem Bug-Tracker durchgeführt werden, ist dies eine gute Möglichkeit, das Testverfahren zu formalisieren.

CSCI-Tests hängen davon ab. Wird es von einer anderen Gruppe gemacht? Wenn ja, dann ja (so). Ist dies der letzte Testschritt vor der Veröffentlichung? Dann ja, denn zu diesem Zeitpunkt sollte Ihre Software als ausgereift angesehen werden. Wenn Sie sich für Metriken interessieren, ist es auch sinnvoll, an dieser Stelle mit der Verfolgung von Fehlern zu beginnen.

Für eine höhere Teststufe sollten Sie Bug-Tracking verwenden. An diesen Punkten sollte Ihre Software als ausgereift betrachtet werden und die Verfolgung von Fehlern ist wichtig.

Veröffentlichung

Sie sollten Fehler im veröffentlichten Code immer nachverfolgen. Dies ist wichtig für die Rechenschaftspflicht.

Es ist auch wichtig, einen Prozess zu optimieren, der Ihren Anforderungen entspricht. Benötigen Sie wirklich ein riesiges Bug-Tracking-System? Sind wirklich alle Felder für ein Team von 2 Personen so wichtig?

Ist es möglich, dass jemand anderes auf den Fehler stößt, möglicherweise in einer älteren Version der Software, die für die Außenwelt freigegeben wurde? In diesem Fall kann es hilfreich sein, sowohl den Fehler als auch den Fix zu protokollieren.

Andere haben vorgeschlagen, dass es sich nicht lohnt, den Fehler zu protokollieren, wenn es länger dauert, als ihn zu beheben. Ich schlage vor, dass die relevante Zeitspanne nicht zwischen dem Auffinden und Beheben des Fehlers liegt, sondern zwischen dem Zeitpunkt, zu dem der Fehler eingeführt wurde, und dem Zeitpunkt, zu dem der Fix veröffentlicht wird.

Wenn der Änderungs- und Veröffentlichungsverlauf anzeigt, dass der Fehler nie das Licht der Welt erblickt hat, sollte es ausreichen, den Fix beim Einchecken in die Quellcodeverwaltung zu protokollieren.

Dies ist ziemlich nah an dieser Frage , aber ich bin nicht sicher, ob es sich um ein Duplikat handelt, da sich dieses auf triviale Korrekturen konzentriert.

Warum sollten Sie Fehler nicht aufspüren, von Jon Arid Torresdal - beheben Sie sie stattdessen.

1. Während der Entwicklung: Sie stoßen auf einen Fehler für ein Feature. Sie fügen einen Testfall hinzu, der den Build bricht , und checken dann das Update gegen das Feature ein.

2. Nach der Freigabe: Dokumentieren Sie das Verhalten . Wenn Sie vorhaben, ein Update zu veröffentlichen, gehen Sie zu Schritt 1. Wenn Sie nicht für dieses Update verantwortlich sind, bewahren Sie den Test + Fix in einem privaten Zweig auf.

Nach der Veröffentlichung des Codes kann es andere Prioritäten geben, und während die Behebung des Fehlers trivial sein kann, ist die Verteilung des Fixes möglicherweise nicht wirtschaftlich, es sei denn, Sie führen eine kontinuierliche Bereitstellung durch.

Hängt davon ab, wie trivial ich diese Maßnahme verwende:

Wenn das Protokollieren länger dauert als das Beheben , lohnt es sich nicht , es zu protokollieren.