La revisione del codice è una buona pratica?

Quando la società in cui lavoro assumeva nuovi manager, ci hanno offerto di fare una panoramica del codice di qualcuno in ogni riunione. Abbiamo incontri ogni due settimane, quindi ogni volta che uno degli sviluppatori mostrava il proprio codice sul proiettore e altri ne discutevano.

Ho pensato che sarebbe stato fantastico: ogni sviluppatore avrebbe prestato maggiore attenzione durante la scrittura del codice e avremmo potuto condividere meglio la nostra esperienza. Ma in qualche modo ci siamo dimenticati di questo e l'offerta è rimasta un'offerta.

Quali sono i vantaggi di questo e ci sono degli svantaggi?

Le revisioni del codice sono un'ottima pratica.

È probabilmente il modo migliore per imparare dagli errori e vedere come determinati problemi vengono risolti da altri. È anche uno dei modi migliori per mantenere la qualità in una base di codice.

Le revisioni del codice avvengono in molte aziende, anche se è difficile dire che esiste un processo specifico che tutte seguono.

Nella revisione del codice più formale, un anziano (o diversi anziani) siederà con uno sviluppatore per rivedere il proprio codice, offrendo suggerimenti e insegnamenti allo stesso tempo.

Ulteriori vantaggi delle revisioni del codice (come commentato per questa domanda), includono:

• Un ottimo modo per insegnare e imparare
• Sono uno dei modi migliori per migliorare e mantenere la coerenza di una base di codice (stile e modi di dire)
• Aiutano a garantire che tutti i membri del team comprendano lo stile e i modi di dire usati nel progetto e come usarli
• Le revisioni del codice accelereranno lo sviluppo man mano che individuano errori e creano difetti in anticipo (quindi, sebbene possano rallentare lo sviluppo iniziale, pagano dividendi nei cicli di sviluppo successivi)
• Esiste un supporto per gli strumenti che aiuta a semplificare il processo di revisione del codice

Le revisioni del codice sono uno strumento molto utile per l'apprendimento , specialmente quando si ha a bordo un nuovo membro del team. Bene, è anche noto come processo di revisione tra pari :)

Esistono diversi tipi di revisioni del codice:

• Over-the-spalla - dove uno sviluppatore guarda oltre la spalla dell'autore del codice mentre quest'ultimo cammina attraverso il codice.
• Pass-around e- mail: il sistema di gestione del codice sorgente invia automaticamente il codice ai revisori dopo aver effettuato il check-in. Estratto dal commento: non sono riuscito a convincere il management ad allocare il tempo per qualsiasi tipo di revisione formale del codice e ho preso in considerazione le modifiche dei miei colleghi ogni volta che ho rimosso le nuove revisioni dal controllo del codice sorgente utilizzando gli strumenti di cronologia / diff integrati in Tortise
• Programmazione di coppia - Due autori sviluppano il codice insieme sulla stessa workstation, cosa comune nella programmazione estrema.
• Revisione del codice assistita da strumenti : autori e revisori utilizzano strumenti specializzati progettati per la revisione del codice peer.

C'è solo uno in associated disadvantagecui le revisioni formali del codice richiedono un investimento considerevole in preparazione dell'evento di revisione e dei tempi di esecuzione.

Più riferimenti sono elencati di seguito (per letture di immersioni più profonde)

• MSDN - Revisione del codice
• Trova e correggi le vulnerabilità prima della spedizione dell'applicazione
• Link Wiki

Quella pratica particolare sembra inefficiente e probabilmente imbarazzante - chi vuole che i loro errori siano segnalati a un intero gruppo di persone. Quindi, se non riescono a scegliere ciò che deve essere rivisto e il codice non è ancora in produzione, questo probabilmente metterà a disagio le persone.

A seconda di quando il codice viene rivisto, può fare una grande differenza nel fatto che i commenti di revisione del codice lo facciano o meno nel codice. Se lo sviluppatore può scegliere e scegliere solo il codice di produzione, è improbabile che i commenti delle recensioni vengano implementati. È bello avere incontri in cui gli sviluppatori possono mettere in mostra alcune tecniche ingegnose a cui hanno appreso che altre persone sarebbero interessate, ma non si tratta di revisione del codice. Questo è allenamento.

Eseguiamo la revisione del codice di ogni pezzo di codice prima che venga spostato nel QA. Ogni pezzo. Coinvolge generalmente solo il revisore del codice e lo sviluppatore. Non passa al QA fino a quando il revisore del codice non lo passa formalmente. Quindi lo sviluppatore deve apportare le modifiche. Abbiamo trovato e risolto rapidamente molti problemi che il QA potrebbe non aver trovato (trovano anche cose che non vediamo anche nella revisione del codice). Inoltre, riduce la codifica dei cowboy e identifica rapidamente le persone che non si comportano bene in modo da poter risolvere i loro problemi e allenarli o eliminarli prima che possano danneggiare la nostra applicazione. Il tempo di revisione del codice fa parte della nostra stima del tempo durante la pianificazione del lavoro, quindi non influisce affatto sulla scadenza. E in realtà, fa risparmiare tempo nel lungo periodo perché prima si trova un problema, più è facile da risolvere.

Personalmente ho insegnato agli sviluppatori meno esperti molte tecniche migliori attraverso la revisione del codice e ho imparato alcune tecniche migliori esaminando il codice di altre persone e i loro commenti sul mio codice. Un'ulteriore revisione del codice garantisce che qualcun altro capisca il codice che contribuisce notevolmente a renderlo più gestibile. A volte, il codice funziona ma le domande della recensione chiariscono che ci saranno problemi di manutenzione perché il codice è difficile da capire. Meglio rifattorizzare in quei casi mentre è ancora tutto nuovo nella tua mente rispetto a un anno dopo quando anche l'autore del codice viene lasciato a grattarsi la testa e chiedersi perché il codice fa così e così.

Il problema con questo tipo di revisione del codice, uno sviluppatore ogni due settimane, i progressi saranno lenti. Potrebbero passare mesi prima che tutti abbiano avuto una svolta sotto i riflettori.

Mentre le revisioni del codice possono essere buone, ci deve essere un motivo dietro e la procedura per eseguirle.

Diverse questioni dovrebbero essere decise:

• Chi sceglierebbe lo sviluppatore e quanta notifica verrebbe data. Nessun avviso sono trappole.
• Chi sceglierebbe la parte di codice da rivedere: gestione, sviluppatore senior del progetto o sviluppatore da rivedere.
• È lo scopo di insegnare alla persona il cui codice è sul proiettore come fare qualcosa di meglio, o è lo scopo per la persona il cui codice è sul proiettore di insegnare a tutti gli altri nella stanza come migliorare il loro codice.
• Quale percentuale di codice verrà esaminata in questo modo, farà parte del processo di QA?

Se le persone che hanno proposto questo piano non hanno già le risposte a queste domande, è possibile che leggano un articolo su come tutte le grandi aziende fanno le revisioni del codice, quindi dovremmo farlo anche senza capire lo scopo dietro di loro.

La revisione del codice è un'ottima pratica, solo quando l'idea per la revisione del codice viene dal team di sviluppo. Gli sviluppatori non hanno bisogno di proiettori e presentazioni per rivedere l'altro codice. Se lo desiderano, preferiranno andare in conferenza.

Quando l'idea della revisione del codice viene dalla direzione, può sembrare un'indagine sulla bassa qualità del software e può demoralizzare il team di sviluppo. Non penso che il management team debba essere coinvolto nel processo di revisione del codice. Revisione del codice fianco a fianco con il management team - pratica molto negativa, omicida e distruttiva.

La revisione del codice è una pratica eccellente, in particolare se viene fatta dagli sviluppatori per condividere le conoscenze e le regole di base sono stabilite in anticipo che suggerimenti e critiche sono pensati per essere COSTRUTTIVI e non usare un singolo sviluppatore per la pratica target.

I manager che non sono sviluppatori saranno accolti con sospetto dagli sviluppatori se decidono di fare revisioni del codice. La maggior parte dei tipi di manager non vorranno entrare nei dettagli che gli sviluppatori hanno intrinsecamente quando guardano il codice. La maggior parte dei manager non capirà perché gli sviluppatori criticano un approccio rispetto all'altro.

Se vuoi mostrare il buon lavoro che gli sviluppatori stanno facendo alla direzione, allora "revisione del codice" ha un significato diverso e non dovrebbe essere così dettagliato come la revisione del codice che viene fatta per istruire / migliorare la qualità del codice tra gli sviluppatori. Questo tipo di presentazione potrebbe essere utile per dimostrare cosa fanno gli sviluppatori se la presentazione può essere di livello superiore e meno specifica del codice, concentrandosi su ciò che i manager comprendono (valore, ROI, ecc.). Potrebbe far capire ai manager che Joe ha aggiunto un valore significativo all'azienda costruendo X, che possiamo mostrare per risparmiare tempo Y o Z dollari per ordine, ecc. Penso che valga la pena di mostrare il valore dell'individuo membri della tua squadra. Ricorda, tuttavia, che devi stare attento a non sopraffare il tuo pubblico con gergo o troppi livelli di dettaglio.

Anche se concordo pienamente sul fatto che le revisioni del codice sono molto costruttive per l'insegnamento, vorrei comunque sottolineare, per me, è garantire che i modelli di progettazione del team siano seguiti correttamente.

Scriviamo un piccolo prototipo e rielaboriamo frammenti di codice e, mentre alla fine ci sentiamo a nostro agio con il prodotto, la leggibilità è stata danneggiata - le persone non possono guardarlo e vedere chiaramente cosa sta succedendo.

Gli occhi indipendenti sono sempre utili, trovo che rimani bloccato in alcuni modi di pensare e questo è a tutti i livelli di esperienza. Hai investito ore nella progettazione e nel codice e quindi è difficile gestire le revisioni del codice quando c'è la paura che i tuoi sforzi vengano eliminati. Eppure alla fine, si spera, si finisce con un'applicazione più pulita, più snella e più gestibile e l'esperienza è radicata in te.

Per il nostro team facciamo come indicato da @ElYusubov e utilizziamo uno strumento specifico per Code Review - Crucible. Le persone esaminano, commentano e firmano il codice. Ogni settimana ci sediamo e rivediamo faccia a faccia pezzi di codice interessanti e / o complessi.

Come tirocinante di ingegneria del software, ho trovato le recensioni di codice estremamente utili.

Nel mio team, è necessaria una revisione del codice per ogni commit (i grandi cambiamenti finiscono per essere formali, i piccoli cambiamenti finiscono per essere "quick look"). Sicuramente mi sento come se le mie costolette di ingegneria / progettazione fossero state potenziate da questo, soprattutto perché ho più probabilità di estrarre immediatamente la lavagna rispetto al terminale poiché so di essere "guardato". :)

In effetti, penso che produca un codice molto migliore con l'unico leggero svantaggio che è un tempo di sviluppo leggermente più lento (che a mio avviso, ne vale la pena nel lungo periodo quando non è necessario correggere / estendere un codice progettato in modo terribile). Inoltre, penso che se hai junior / stagisti nella squadra apprezzeranno la possibilità di un feedback prezioso. Lo so che lo faccio!

Dalla mia esperienza, Code Review è davvero una grande cosa se la esegui bene. Quando hai membri del team e manager professionisti / maturi. Noi programmatori siamo "risolutori di soluzioni". Il nostro compito non è quello di creare righe di "testo". Ecco perché dobbiamo condividere idee, errori, problemi, esperienze. La revisione del codice è davvero una buona pratica per raggiungere questo obiettivo.

Purtroppo suona alla grande, ma è davvero difficile da implementare nella maggior parte delle aziende. La tua squadra ha bisogno di molta "autonomia". Convincere i tuoi dirigenti o il tuo dipartimento finanziario che non è proficuo creare nuove funzionalità sembra difficile.

Nella mia azienda stiamo provando a fare un po 'di revisione del codice. Ma si passa troppo tempo a "rincorrere il coniglio" (creare funzionalità).

Oggigiorno gran parte dei controlli di tipo e di sintassi di base vengono rilevati utilizzando gli strumenti (FXCop ecc.).

Tuttavia, le revisioni del codice sono buone, specialmente con i nuovi membri di un team, cose complesse o di grande impatto (ad esempio qualcosa che sarà evidente a persone importanti se falliscono o causano un impatto aziendale) e specialmente quando si esternalizzano o si utilizzano appaltatori a breve termine (specialmente di nuovo quando sono madrelingua poiché errori di traduzione / problemi di lingua possono consentire al software di superare tutti i test ma non fare esattamente ciò che dovrebbe).

Non sono un fan di mettere il codice su un proiettore per far sì che una squadra possa passare - molto meglio avere una riunione di revisione del codice in cui un altro membro del team (responsabile della squadra ecc.) Passa attraverso un elenco con lo sviluppatore. Questo ha un impatto su meno persone - blocca molto tempo sprecato su argomenti di stile - ed è meno imbarazzante per gli sviluppatori. È più costruttivo e più facile per lo sviluppatore assorbire problemi reali e non essere accecato da "Avrei fatto questo ..." sorta di commenti.

Penso anche che le revisioni non forzate del codice - come mettere il codice su una condivisione o inviarlo via e-mail nella speranza che qualcuno rinunci all'ora di pranzo per passarci attraverso - sia una perdita di tempo.

Sedersi con una pila di elenchi, un pennarello e una tazza di caffè nell'area del caffè è ottimo per questo.

Questo tipo di spettacolo collettivo sarebbe utile per le nuove tecnologie o per ottenere diversi jr. si dedica alla velocità, ma non credo sia buono come una revisione coerente del nuovo codice. È più efficiente doverlo fare uno a uno.

La revisione del codice aiuta a vedere "l'intero". Gli sviluppatori separati hanno la tendenza a vedere solo i loro requisiti / problemi. CR scopre idee e soluzioni da tutta la prospettiva. CR aiuta principalmente a eliminare gli sprechi di lavoro inutile. L'intero prodotto è più economico e di migliore qualità.