Ist das Beheben von Bugs, die von anderen gemacht wurden, ein guter Ansatz?

Angenommen, ein Team von vier Entwicklern erstellt eine Anwendung. Während der Testphase werden Fehler von Benutzern gemeldet. Wer sollte sie reparieren? Die Person, die den falschen Code eingegeben hat, oder jemand, der frei ist?

Was ist der bevorzugte Ansatz bei der agilen Entwicklung (Scrum)?

Der bevorzugte Ansatz bei der agilen Entwicklung wäre, sie so schnell wie möglich zu reparieren, je nachdem, wer verfügbar ist. Dies liegt einfach daran, dass der Besitz des Codes nicht einer Person, sondern der gesamten Entwicklergruppe übertragen wird. Wenn eine Person ständig Fehler verursacht, ist dies ein weiteres Problem, das separat angegangen werden muss.

Standardmäßig ist die Person. Der Grund ist ganz einfach: Feedback. Bugs bieten eine großartige Möglichkeit für persönliches und professionelles Feedback. Wenn jemand anderes meine Fehler beheben würde, würde ich denselben Fehler erneut machen, weil ich daraus nicht lernen würde.

Wenn diese Person nicht verfügbar ist, kann sie von einer anderen Person behoben werden. Die Person sollte jedoch den Lebenszyklus der Fehler verfolgen.

Als PM würde ich es vermeiden, Fehler mit bestimmten Entwicklern zu verknüpfen. Wenn es nötig ist, lassen Sie dies den Funktions- / Entwicklungsleiter tun. Kümmere dich um das Team. Das Team muss einen Fehler beheben.

Ich weiß nicht, wie Scrum mit diesem Szenario umgeht, aber in meinem Team haben wir so etwas wie ein Cross-Testing / Code-Review. Auf diese Weise erörtern Entwickler und Prüfer den besten Lösungsansatz für den Fall, dass ein Fehler gefunden wird.

Ich glaube, solange die Lösung passt, spielt es keine Rolle, ob der Entwickler oder der Reviewer sie anwendet. Es ist jedoch wichtig, Konflikte zwischen Entwickler und Tester zu vermeiden.

Rgds

Bearbeiten: Ich bin mir nicht sicher, ob ich mich klar ausgedrückt habe, aber es ist wichtig hervorzuheben, dass der Prüfer ein anderer Entwickler im Team ist.

1. Bewerten Sie den Fehler
2. Wenn es für den ursprünglichen Entwickler schneller und sinnvoller ist, das Problem zu beheben, geben Sie es ihm
3. Wenn es von irgendjemandem im Team behoben werden kann, lassen Sie es jeden tun.

Ich stimme Steven voll und ganz zu, dass der Code allen Teams gehört. und es gibt noch einige weitere Gründe, warum Sie den Fehler nicht an ihre Schöpfer weitergeben sollten:

Wie ich weiß, ist es in vielen Fällen schwierig festzustellen, wer den Fehler verursacht hat. Selbst wenn Sie ein Dokumentenverwaltungssystem wie SVN verwenden, kann das Auffinden des Fehlercodes viel Zeit in Anspruch nehmen. Also, meiner Meinung nach, gib einfach den Bug für jeden, der frei ist.

Wenn Sie nachverfolgen möchten, wie der Fehler aufgetreten ist, können Sie in Ihrer Freizeit den Reparaturbetrieb nach dem Fall fragen (vor allen anderen Teams). Da Ihr Team klein ist, würde dies meiner Meinung nach die Erfahrung mit möglichen Fehlern teilen und niemanden in Verlegenheit bringen.

Es gibt nur drei Gründe, sich darum zu kümmern, wer einen Fehler behebt: Kosten, Geschwindigkeit und berufliche Entwicklung.

Und für alle drei gibt es Vor- und Nachteile. Zum Beispiel berufliche Entwicklung, zum einen ist es eine Gelegenheit, mehr über den Code zu lernen, zum anderen ist es eine Gelegenheit, die Art von Fehlern zu erkennen, die Sie machen, und in Zukunft einige zu vermeiden. Oder nehmen Sie sich die Kosten, wahrscheinlich die, die den Fehler verursacht haben, um ihn schneller und wahrscheinlich billiger zu beheben. Andererseits entstehen Kosten für die Zeit, die aufgewendet wird, um herauszufinden, wer den Fehler begangen hat, und um ihn der entsprechenden Person zuzuweisen - Zeit Dies übersteigt in vielen Fällen das Problem der Fehlerbehebung.

Der agile Ansatz besteht darin, die Entwickler das Problem selbst zuweisen zu lassen. Ich würde das nur aus einem guten Grund außer Kraft setzen.

In meinem Team entscheiden wir immer nach Priorität. Wenn die Person, die den Code eingereicht hat, verfügbar ist, korrigiert sie den Code. Wenn diese Person an einer Story mit höherer Priorität arbeitet, wird sie von jedem behoben, der verfügbar ist und den Code so schnell wie möglich reparieren kann. Wenn alle mit der Arbeit an Aufgaben mit höherer Priorität in der aktuellen Iteration beschäftigt sind, wird der Fix in der nächsten Iteration gemäß seiner Priorität im Vergleich zu den anderen Storys und Fehlern geplant.

Denken Sie an: Wer hat mehr Informationen über den Fehler? Das Entwicklungsteam.

Lassen Sie sie also entscheiden, was mit dem Fehler geschehen soll. Sie besitzen den Code und sind dafür verantwortlich.

Sie können ihnen helfen, indem Sie das Projekt verwalten, einige Zeit für die Behebung von Fehlern auf den Projektumfang verwenden und sie die Arbeit alleine erledigen lassen.

Vermeiden Sie es, zu viele Entscheidungen zu treffen, wenn Sie (als PM-Rolle) weniger Informationen haben als das Team.

Siehe die Frage zu: Wie vermeide ich die Mikroverwaltung eines Softwareentwicklungsteams?

Ich sage, Sie brauchen ein Fehlerverfolgungssystem, um Fehler aufzuzeichnen, die durch das, was gemeldet wurde, verursacht wurden, und die Fehler dann verschiedenen Personen zuzuweisen, basierend auf ihrer Arbeitslast. Außerdem wird angegeben, durch welchen Code der Fehler verursacht wurde. Anschließend wird in einem Bericht angegeben, wie viele Codierer und welche Apps x Fehler während der Woche verursacht haben.

Dann können Sie das den Programmierern zeigen, um zu zeigen, wie sie Fehler verursachen.

Und der beste Weg, um Fehler zu vermeiden, ist, alle daran zu beteiligen, sie zu beheben. Ich meine, weisen Sie verschiedenen Personen eine Fehlerbehebung zu, um zu erfahren, was Fehler verursacht und was sie behebt.

Vielleicht überarbeiten oder erstellen Sie dann nach ein oder zwei Monaten, in denen Fehler behoben wurden, Ihre Kodierungsrichtlinie, um zukünftige systemweite Fehler zu vermeiden, indem Sie Standards für Ihre Programmierweise geschrieben / dokumentiert haben.

Wenn ein Fehler gefunden wird, liegt es in der Verantwortung des gesamten Entwicklungsteams, ihn zu beheben.

Wenn die Leute glauben, dass ein Fehler vom Autor behoben werden sollte, dann ist das so, als würde man sagen "Ich behebe das Problem nicht, das Loch ist nicht auf meiner Seite des Bootes". Aber das Boot sinkt immer noch, wenn das Loch nicht repariert ist und Sie mit allen anderen auf dem Boot sind.

Einzelpersonen müssen erkennen, dass sie Teil eines Teams sind, und verstehen, dass der Kodex zusammen mit seinen Verantwortlichkeiten allen von ihnen gehört. Der Erfolg eines Projekts beruht auf allen Teammitgliedern.