I commenti in linea "modificati da" sono la norma nei negozi che utilizzano il controllo di revisione?


17

Il senior dev nel nostro negozio insiste sul fatto che ogni volta che il codice viene modificato, il programmatore responsabile dovrebbe aggiungere un commento in linea affermando ciò che ha fatto. Questi commenti di solito sembrano// YYYY-MM-DD <User ID> Added this IF block per bug 1234.

Usiamo TFS per il controllo delle revisioni e mi sembra che commenti di questo tipo siano molto più appropriati come note di check-in piuttosto che di rumore in linea. TFS ti consente anche di associare un check-in a uno o più bug. Alcuni dei nostri vecchi file di classe spesso modificati sembrano avere un rapporto commenti / LOC che si avvicina a 1: 1. A mio avviso, questi commenti rendono il codice più difficile da leggere e aggiungono valore zero.

È una pratica standard (o almeno comune) in altri negozi?


12
Concordo con te, ecco a cosa servono i registri di revisione nel controllo versione.
TZHX,

1
Lo sviluppatore senior del tuo team lo ha fatto prima che il controllo della versione fosse diffuso e non si è reso conto che appartiene a qualcun altro per rimuovere l'odore del codice. Mostragli sei progetti open source che utilizzano un sistema bugzilla e vc, chiedigli se aveva bisogno di sapere nei commenti della libreria jQuery che $ .ajax () è stato recentemente modificato da jaubourg 4 mesi fa e tutte le modifiche minori fatto anche da centinaia di persone. L'intera libreria jQuery sarebbe un disastro di commenti e non è stato ottenuto nulla!
Incognito,

1
In realtà abbiamo una politica non scritta senza nomi nel codice sorgente in quanto può creare un senso di proprietà del codice che è considerato un BadThing TM.
Stephen Paulger,

Risposte:


23

Di solito considero tali commenti una cattiva pratica e penso che questo tipo di informazioni appartenga ai registri di commit di SCM. Rende il codice più difficile da leggere nella maggior parte dei casi.

Tuttavia , faccio spesso qualcosa del genere per tipi specifici di modifiche.

Caso 1 - Attività

Se usi un IDE come Eclipse, Netbeans, Visual Studio (o hai qualche modo di fare ricerche di testo sulla tua base di codice con qualsiasi altra cosa), forse il tuo team usa alcuni "tag di commento" o "tag di attività" specifici. Nel qual caso questo può essere utile.

Di tanto in tanto, quando rivedo il codice, aggiungo qualcosa di simile al seguente:

// TOREVIEW: [2010-12-09 haylem] marking this for review because blablabla

o:

// FIXME: [2010-12-09 haylem] marking this for review because blablabla

Per questo uso diversi tag di attività personalizzati che posso vedere in Eclipse nella vista attività, perché avere qualcosa nei registri di commit è una buona cosa ma non abbastanza quando hai un dirigente che ti chiede in una riunione di revisione perché il bugfix XY è stato completamente dimenticato e scivolò attraverso. Quindi su questioni urgenti o pezzi di codice davvero discutibili, questo serve come promemoria aggiuntivo (ma di solito terrò breve il commento e controllerò i registri di commit perché QUESTO è il motivo per cui il promemoria è qui, quindi non ingombrare troppo il codice tanto).

Caso 2 - Patch di lib di terze parti

Se il mio prodotto deve impacchettare un pezzo di codice di terze parti come sorgente (o libreria, ma ricostruito dal sorgente) perché per qualche motivo doveva essere patchato, documentiamo la patch in un documento separato in cui elenchiamo quei "avvertimenti" per riferimento futuro, e il codice sorgente di solito conterrà un commento simile a:

// [PATCH_START:product_name]
//  ... real code here ...
// [PATCH_END:product_name]

Caso 3 - Correzioni non evidenti

Questo è un po 'più controverso e più vicino a ciò che chiede il tuo senior dev.

Nel prodotto su cui lavoro al momento, a volte (sicuramente non è una cosa comune) abbiamo un commento come:

// BUGFIX: [2010-12-09 haylem] fix for BUG_ID-XYZ

Lo facciamo solo se la correzione non è ovvia e il codice viene letto in modo anomalo. Questo può essere il caso delle stranezze del browser, ad esempio, o oscure correzioni CSS che devi implementare solo perché c'è un bug di documento in un prodotto. Quindi, in generale, lo collegheremo al nostro archivio di problemi interni, che conterrà quindi il ragionamento dettagliato dietro il bugfix e i puntatori alla documentazione del bug del prodotto esterno (diciamo, un avviso di sicurezza per un noto difetto di Internet Explorer 6, oppure qualcosa del genere).

Ma come detto, è abbastanza raro. E grazie ai tag attività, possiamo eseguirli regolarmente e verificare se queste strane correzioni hanno ancora senso o possono essere eliminate gradualmente (ad esempio, se abbiamo abbandonato il supporto per il prodotto difettoso causando in primo luogo il bug).


Questo solo in: un esempio di vita reale

In alcuni casi, è meglio di niente :)

Mi sono imbattuto in un'enorme classe di calcolo statistico nella mia base di codice, in cui il commento dell'intestazione era sotto forma di un log delle modifiche con il solito yadda yadda: revisore, data, ID bug.

All'inizio ho pensato di scartare, ma ho notato che gli ID dei bug non solo non corrispondevano alla convenzione del nostro attuale tracker dei problemi, ma non corrispondevano nemmeno a quelli del tracker usato prima che mi unissi alla compagnia. Quindi ho cercato di leggere il codice e capire cosa stava facendo la classe (non essendo uno statistico) e ho anche cercato di scoprire questi rapporti sui difetti. Di fatto erano abbastanza importanti e avrebbero modificato la vita del prossimo ragazzo per modificare il file senza conoscerli abbastanza orribilmente, dato che si trattava di problemi di precisione minori e casi speciali basati su requisiti molto specifici emessi dal cliente originario di allora . In conclusione, se questi non fossero stati lì, non lo avrei saputo. Se non fossero stati lì dentro E avessi avuto una migliore comprensione della classe,

A volte è difficile tenere traccia di requisiti molto vecchi come questi. Alla fine quello che ho fatto è stato comunque rimuovere l'intestazione, ma dopo aver nascosto un commento a blocchi prima di ogni funzione incriminante che descriveva il motivo per cui questi "strani" calcoli sono richieste specifiche.

Quindi in quel caso li consideravo ancora una cattiva pratica, ma ragazzo ero contento che lo sviluppatore originale li avesse almeno messi dentro! Sarebbe stato meglio invece commentare chiaramente il codice, ma credo che fosse meglio di niente.


Queste situazioni hanno un senso. Grazie per l'input.
Joshua Smith,

il secondo caso è un normale commento in codice sul perché c'è una patch nel codice. il primo caso è valido: solo un'osservazione che il codice non è finito o c'è ancora del lavoro da fare su quella parte.
Salandur,

Bene, lo sviluppatore senior nel mio posto di lavoro (me) afferma che le modifiche vanno nei commenti di commit del sistema di gestione della configurazione del software. Hai il tuo SCM e i tracker dei difetti collegati, giusto? (google SCMBUG) Non fare manualmente ciò che può essere automatizzato.
Tim Williscroft,

@Tim: bene, sono d'accordo con te, come dice la prima riga della risposta. Ma in casi non ovvi, i programmatori (per pigrizia, presumo, poiché non vogliono perdere tempo su di esso) non controlleranno i registri di commit e mancheranno alcune informazioni chiave, mentre un commento 10char può indicarli l'ID corretto del bug che conterrà i registri delle revisioni relative a quel bug se hai configurato SCM e tracker per lavorare insieme. Il migliore di tutti i mondi, davvero.
Hayylem,

Nella mia esperienza, i messaggi di commit sono spesso omessi (nonostante le politiche per includerli, se esistono) o sono inutili (solo un numero di problema e spesso quello sbagliato). Quelle stesse persone tuttavia lasceranno commenti nel codice ... Preferirei avere questi e nessun messaggio di commit piuttosto che niente (e in molti ambienti in cui ho lavorato per ottenere i messaggi di commit / la cronologia di origine era così difficile che era quasi impossibile , fino a includere la necessità di richiedere fonti ad altre persone perché l'accesso al controllo della versione era limitato "per motivi di sicurezza").
jwenting

3

Usiamo questa pratica per i file non sotto il controllo della versione. Abbiamo programmi di gioco di ruolo che funzionano su un mainframe ed è stato difficile fare molto di più che eseguirne il backup.

Per il codice sorgente con versione, utilizziamo le note per il check-in. Penso che sia quello a cui appartengono, non ingombrando il codice. Sono metadati, dopo tutto.


Sono d'accordo, i file non sotto il controllo della versione sono una storia diversa.
Joshua Smith,

1
"dimostrato difficile fare molto di più che eseguirne il backup." Non è proprio una scusa per il mio CTO.
Tim Williscroft,

@Tim: sempre aperto ai suggerimenti: posso sollevarli nella catena di comando. :) Il mainframe è difficile da lavorare per ottenere e disattivare i file.
Michael K,

Il mio consiglio: presumibilmente puoi toglierli (backup); perché non scaricarlo da qualche parte e avere una piccola sceneggiatura che spinga le modifiche a mercurial ogni notte?
Wyatt Barnett,

2

Avevamo questa pratica molto tempo fa in un negozio di software in cui il nostro manager insisteva sul fatto che voleva essere in grado di leggere i file di codice su carta e seguire la loro cronologia delle revisioni. Inutile dire che non ricordo alcuna occasione concreta in cui guardò effettivamente una stampa del file sorgente: - /

Fortunatamente, i miei manager da allora sono stati più informati su cosa possono fare i sistemi di controllo della versione (devo aggiungere che abbiamo usato SourceSafe in quel primo negozio). Quindi non aggiungo metadati di versioning nel codice.


2

In genere non è necessario se SCM e IDE ti consentono di utilizzare la funzione "mostra annotazione" (chiamata comunque in Eclipse), puoi facilmente vedere quali commit hanno modificato un pezzo di codice e i commenti di commit dovrebbero dire chi e perché.

L'unica volta che inserirò un commento come questo nel codice è se è un pezzo di codice particolarmente strano che può causare confusione in futuro, commenterò brevemente con il numero del bug in modo che possano andare alla segnalazione e leggere in dettaglio.


"non ti aspetti di capirlo" è probabilmente un brutto commento da inserire nel codice. Di nuovo, dirò di collegare insieme SCM e tracker di bug.
Tim Williscroft,

2

Ovviamente, tali commenti sono quasi garantiti per essere errati nel tempo; se modifichi una riga due volte, aggiungi due commenti? Dove vanno? Quindi un processo migliore è fare affidamento sui tuoi strumenti.

Questo è un segno che, per qualsiasi motivo, lo sviluppatore senior non può fare affidamento sul nuovo processo per tenere traccia delle modifiche e collegare le modifiche al sistema di tracciabilità dei problemi. È necessario affrontare questo disagio per risolvere il conflitto.

Devi capire perché non può fare affidamento su di esso. Sono vecchie abitudini? Una brutta esperienza con il sistema SCM? Un formato di presentazione che non funziona per lui? Forse non sa nemmeno di strumenti come 'git blame' e la vista della sequenza temporale di Perforce (che essenzialmente mostra questo, anche se potrebbe non mostrare quale problema abbia innescato il cambiamento).

Senza capire la sua ragione per il requisito, non sarai in grado di convincerlo.


2

Lavoro su un prodotto Windows di oltre 20 anni. Abbiamo una pratica simile che esiste da molto tempo. Non riesco a contare il numero di volte che questa pratica ha salvato la mia pancetta.

Sono d'accordo che alcune cose sono ridondanti. Un tempo gli sviluppatori usavano questa pratica per commentare il codice. Quando lo rivedo, dico loro di andare avanti ed eliminare il codice e il commento non è necessario.

Ma, molte volte, si arriva a guardare il codice che è stato circa un decennio e modificato da 20 sviluppatori ma mai rifattorizzato. Tutti hanno dimenticato da tempo tutti i dettagli dei requisiti contenuti nel codice originale, non importa tutte le modifiche e non esiste una documentazione affidabile.

Un commento con un numero di difetto mi dà un posto dove andare a cercare l'origine del codice.

Quindi, sì, il sistema SCM fa molto, ma non tutto. Trattali come faresti con qualsiasi altro commento e aggiungili ogni volta che viene apportata una modifica significativa. Lo sviluppatore esamina il tuo codice oltre 5 anni da come ti ringrazierà.


1

Menzionare ogni cambiamento nei commenti è inutile se si dispone di un VCS. È utile menzionare un bug specifico o altre note importanti relative a una riga specifica . Una modifica può includere molte righe modificate, tutte sotto lo stesso messaggio di commit.


1

Non che io possa dire.

Colpisco TODO nel mio codice mentre procedo, e l'obiettivo è di rimuoverli entro il tempo di revisione.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.