Una revisione del codice è soggettiva o oggettiva (quantificabile)?


55

Sto mettendo insieme alcune linee guida per le revisioni del codice. Non abbiamo ancora un processo formale e stiamo cercando di formalizzarlo. E il nostro team è distribuito geograficamente.

Stiamo usando TFS per il controllo del codice sorgente (lo abbiamo usato anche per attività / tracciamento dei bug / gestione dei progetti, ma lo abbiamo migrato su JIRA ) con Visual Studio 2008 per lo sviluppo.

Quali sono le cose che cerchi quando fai una revisione del codice?

  • Queste sono le cose che mi sono venute in mente
    1. Applica regole FxCop (siamo un negozio Microsoft)
    2. Controlla le prestazioni (eventuali strumenti?) E la sicurezza (pensando di utilizzare OWASP - crawler di codice ) e la sicurezza dei thread
    3. Aderire alle convenzioni di denominazione
    4. Il codice dovrebbe comprendere casi limite e condizioni al contorno
    5. Gestire correttamente le eccezioni (non ingerire eccezioni)
    6. Controlla se la funzionalità è duplicata altrove
    7. Un corpo di metodo dovrebbe essere piccolo (20-30 righe) e i metodi dovrebbero fare solo una cosa e una cosa (nessun effetto collaterale ed evitare l'accoppiamento temporale -)
    8. Non passare / restituire valori null nei metodi
    9. Evita il codice morto
    10. Documentare metodi / proprietà / variabili pubblici e protetti

Quali altre cose dovremmo generalmente cercare?

Sto cercando di vedere se siamo in grado di quantificare il processo di revisione (che produrrebbe un output identico se esaminato da persone diverse) Esempio: Dire "il corpo del metodo non dovrebbe essere più lungo di 20-30 righe di codice" invece di dire "il metodo il corpo dovrebbe essere piccolo ".

Oppure la revisione del codice è molto soggettiva (e differirebbe da un recensore all'altro)?

L'obiettivo è disporre di un sistema di marcatura (ad esempio -1 punto per ogni violazione della regola FxCop, -2 punti per non seguire le convenzioni di denominazione, 2 punti per il refactoring, ecc.) In modo che gli sviluppatori siano più attenti quando controllano il loro codice. In questo modo, possiamo identificare gli sviluppatori che scrivono costantemente codice buono / cattivo. L'obiettivo è fare in modo che il revisore impieghi circa 30 minuti al massimo, per fare una recensione (so che è soggettivo, considerando il fatto che il changeset / revisione potrebbe includere più file / enormi modifiche all'architettura esistente, ecc., Ma ottieni l'idea generale, il recensore non dovrebbe passare giorni a rivedere il codice di qualcuno).

Quale altro sistema oggettivo / quantificabile segui per identificare il codice buono / cattivo scritto dagli sviluppatori?

Riferimento del libro: Clean Code: un manuale di agile software artigianale di Robert Martin .


8
Cosa è considerato dannoso nel restituire null? Capisco perché di solito è meglio in linguaggi di alto livello, come C #, restituire array vuoti invece di NULL (rende il codice molto più elegante e più semplice per evitare errori). A volte è necessario restituire un riferimento NULL, giusto?

4
Se evitiamo di restituire valori null, possiamo saltare il controllo dei valori null quando l'app / libreria client / che consuma chiama il nostro metodo. da Clean Code di Robert Martin - Chapter 7 (Error Handling) pp: 110 "Quando ritorniamo null, stiamo essenzialmente creando lavoro per noi stessi e combattendo i problemi sui nostri chiamanti. Basta inviare un controllo null mancante per inviare un'applicazione che gira fuori di controllo ".

3
Puoi spiegarlo a qualcuno che non vuole comprare il libro per leggere una pagina :)? Sembra che per la maggior parte dei programmi C #, evitare NULL renderà il codice più complesso, che a sua volta è una ricetta per più errori ...

2
Ecco un post sul blog che spiega perché restituire null è una cattiva idea. thehackerchickblog.com/2008/10/… . E un altro leedumond.com/blog/should-we-return-null-from-our-methods . Ciò che Bob suggerisce nel suo libro è se siamo tentati di restituire null, possiamo lanciare un'eccezione di riferimento Null o restituire un oggetto SPECIAL_CASE. Pensa a concatenare le chiamate al metodo this.Foo().FooBar().FooBarBar(); Se l'oggetto restituito qui da Foo è nullo, puoi sicuramente evitare "Riferimento oggetto non impostato su un'istanza di un oggetto" quando chiami FooBar ()

@SoloBold: E solo per sottolineare, sono solo linee guida. Se c'è un motivo molto convincente per restituire null (può essere, in alcuni casi), restituire null avrebbe senso piuttosto che restituire un oggetto SPECIAL_CASE

Risposte:


25

Valutare le persone in una recensione è contrario ai sistemi di maggior successo con cui ho lavorato, forse a tutti. Ma l'obiettivo che ho cercato di raggiungere per oltre 20 anni è meno bug e aumento della produttività all'ora dell'ingegnere. Se la valutazione delle persone è un obiettivo, suppongo che le recensioni potrebbero essere utilizzate. Non ho mai visto una situazione in cui era richiesto, come lavoratore o come leader.

Alcuni studi oggettivi (Fagan, ecc.) E molta saggezza popolare suggeriscono che le relazioni tra pari facilitano le revisioni del codice volte a ridurre i bug e aumentare la produttività. I dirigenti che lavorano possono partecipare come lavoratori, ma non come dirigenti. Sono noti i punti di discussione, le modifiche per soddisfare i revisori sono generalmente buone ma non richieste. Da qui la relazione tra pari.

Eventuali strumenti automatici che possono essere accettate senza ulteriori analisi o giudizio sono buone - lint in C, C ++, Java. Compilazione regolare. I compilatori sono DAVVERO bravi a trovare i bug del compilatore. Documentare le deviazioni nei controlli automatici sembra una sottile accusa nei confronti dei controlli automatici. Le direttive sul codice (come fa Java) che consentono deviazioni sono piuttosto pericolose, IMHO. Ottimo per il debug, per consentire di ottenere rapidamente il nocciolo della questione. Non così bello da trovare in un blocco di codice di 50.000 righe non commentato male di cui sei diventato responsabile.

Alcune regole sono stupide ma facili da applicare; valori predefiniti per ogni istruzione switch anche quando non sono raggiungibili, ad esempio. Quindi è solo una casella di controllo e non è necessario dedicare tempo e denaro a testare valori che non corrispondono a nulla. Se hai delle regole , avrai follia , sono indissolubilmente legate . Ogni beneficio di una regola dovrebbe valere la follia che costa e tale relazione dovrebbe essere controllata ad intervalli regolari.

D'altra parte, "Funziona" non è una virtù prima della revisione o della difesa in revisione. Se lo sviluppo ha seguito il modello a cascata , ti piacerebbe fare la revisione quando la codifica è completa all'85%, prima che vengano individuati e risolti errori complicati, perché la revisione è un modo più economico per trovarli. Poiché la vita reale non è il modello a cascata, quando rivedere è in qualche modo un'arte e equivale a una norma sociale. Le persone che leggeranno effettivamente il tuo codice e cercheranno problemi in esso sono oro massiccio. La gestione che supporta questo in modo continuativo è una perla al di sopra del prezzo. Le recensioni dovrebbero essere come check-in, presto e spesso .

Ho trovato queste cose utili:

1) Nessuna guerra di stile . Dove vanno le parentesi graffe aperte dovrebbero essere soggette a un controllo di coerenza in un determinato file. Lo stesso. Va bene allora. Profondità del rientro Ditto ** se ** larghezze della linguetta . La maggior parte delle organizzazioni scopre di aver bisogno di uno standard comune per le schede, che viene utilizzato come ampio spazio.

2) `Ragged

   looking

testo che non lo fa

   line up is hard to read 

per i contenuti

A proposito, K&R ha indentato cinque spazi (CINQUE), quindi gli appelli all'autorità sono privi di valore. Sii coerente.

3) Una copia numerata di riga, immutabile, disponibile pubblicamente del file da rivedere dovrebbe essere indicata per 72 ore o più prima della revisione.

4) Nessun design al volo. Se c'è un problema o un problema, annota la sua posizione e continua a muoverti.

5) I test che attraversano tutti i percorsi nell'ambiente di sviluppo sono un'idea molto, molto, molto, buona. I test che richiedono enormi dati esterni, risorse hardware, uso del sito del cliente, ecc., Sono test che costano una fortuna e non saranno approfonditi.

6) Un formato di file non ASCII è accettabile se esistono strumenti di creazione, visualizzazione, modifica, ecc. O vengono creati all'inizio dello sviluppo. Questo è un mio pregiudizio personale, ma in un mondo in cui il sistema operativo dominante non può uscire a modo suo con meno di 1 gigabyte di RAM, non riesco a capire perché i file inferiori a, diciamo, 10 megabyte dovrebbero essere qualsiasi cosa diverso da ASCII o qualche altro formato supportato commercialmente. Esistono standard per grafica, audio, film, file eseguibili e strumenti che li accompagnano. Non ci sono scuse per un file contenente una rappresentazione binaria di un numero di oggetti.

Per la manutenzione, il refactoring o lo sviluppo del codice rilasciato, un gruppo di collaboratori che avevo usato per la revisione da un'altra persona, seduto a un display e guardando un diff di vecchio e nuovo , come gateway per il check-in in filiale. Mi è piaciuto, era economico, veloce, relativamente facile da fare. Le procedure dettagliate per le persone che non hanno letto il codice in anticipo possono essere educative per tutti ma raramente migliorare il codice dello sviluppatore.

Se sei distribuito geograficamente, guardare le differenze su uno schermo mentre parli con qualcun altro che guarda lo stesso sarebbe relativamente facile. Questo riguarda due persone che osservano i cambiamenti. Per un gruppo più numeroso che ha letto il codice in questione, più siti non è molto più difficile di tutti in una stanza. Le stanze multiple collegate da schermi di computer condivisi e squak box funzionano molto bene, IMHO. Più siti, maggiore è la gestione delle riunioni. Un manager in qualità di facilitatore può guadagnare la loro permanenza qui. Ricorda di continuare a eseguire il polling dei siti in cui non ti trovi.

A un certo punto, la stessa organizzazione aveva un test unitario automatizzato che veniva utilizzato come test di regressione. È stato davvero bello. Ovviamente abbiamo quindi cambiato piattaforma e i test automatici sono stati lasciati indietro. La revisione è migliore, come rileva il Manifesto Agile , le relazioni sono più importanti del processo o degli strumenti . Ma una volta ottenuta la revisione, i test di unità automatizzati / test di regressione sono il prossimo aiuto più importante nella creazione di un buon software.

Se puoi basare i test sui requisiti , beh, come dice la signora in "Quando Harry incontrò Sally" , avrò quello che sta avendo!

Tutte le recensioni devono avere un parcheggio per acquisire requisiti e problemi di progettazione al livello sopra indicato. Una volta che qualcosa viene riconosciuto come appartenente al parcheggio, la discussione dovrebbe fermarsi nella recensione.

A volte penso che la revisione del codice dovrebbe essere come una revisione schematica nella progettazione dell'hardware: completamente pubblica, approfondita, tutorial, la fine di un processo, un gateway dopo il quale viene costruito e testato. Ma le revisioni schematiche sono pesanti perché cambiare gli oggetti fisici è costoso. Le revisioni di architettura, interfaccia e documentazione per il software dovrebbero essere probabilmente pesanti. Il codice è più fluido. La revisione del codice dovrebbe essere più leggera.

In molti modi, penso che la tecnologia riguardi tanto la cultura e le aspettative quanto uno strumento specifico. Pensa a tutte le improvvisazioni " Swiss Family Robinson " / Flintstones / McGyver che deliziano il cuore e sfidano la mente. Vogliamo che le nostre cose funzionino . Non esiste un unico percorso, non più di quanto non esistesse l '"intelligenza" che potrebbe in qualche modo essere astratta e automatizzata dai programmi di intelligenza artificiale degli anni '60 .


Questa è una buona risposta, in particolare per quanto riguarda il voto delle persone - questo non dovrebbe essere il punto di una revisione del codice.
Paddy,

25

La maggior parte dei punti che hai descritto sono solo una questione di formulazione del codice o roba "di superficie":

  • Aderire alle convenzioni di denominazione
  • Evita il codice morto
  • Documento
  • ...

Tutto ciò può essere verificato usando uno strumento automatico : non c'è bisogno che uno sviluppatore esperto passi del tempo a cercare il codice.

Non so nulla di .NET , ma, per PHP , abbiamo strumenti per controllare quel tipo di cose; considerando che .NET viene spesso definito "più industriale" rispetto a PHP, sarei sorpreso di apprendere che non esiste uno strumento per controllare quel tipo di cose.


Lo strumento automatizzato può sia:

  • Essere integrato in un processo di compilazione automatica , che viene eseguito ogni notte
  • Invia rapporti via e-mail
    • avvisi (ad esempio, un metodo è più lungo di 20 righe)
    • errori (ad esempio, un metodo è più lungo di 50 righe)

La posta può essere inviata a tutto il team o al tipo che ha commesso il codice che non supera un test, oppure è possibile utilizzare un'interfaccia Web di reporting (stessa nota su .NET e PHP)


Vorrei anche aggiungere che i test automatici possono aiutare molto, per rilevare un certo numero di errori prima che il codice venga utilizzato in produzione. E suppongo che anche i test automatici possano aiutare con alcune metriche.


Le recensioni di codice fatte da sviluppatori esperti hanno anche un altro grande vantaggio di cui non hai parlato:

  • Uno sviluppatore esperto può spesso rilevare una grande varietà di bug semplicemente guardando il codice sorgente (trovo abbastanza spesso bug quando faccio recensioni di codice)
  • Una revisione del codice fatta da un esperto sviluppatore gli consentirà di fare commenti e raccomandazioni al team :
    • Proverà a comprendere gli algoritmi utilizzati nel codice e, eventualmente, a suggerire soluzioni migliori.
    • Semplicemente leggendo il codice, ci sono spesso cose che puoi vedere che uno strumento automatico non rileverà.

Ma per una revisione del codice più profonda della semplice formattazione del codice, avrai bisogno di più di mezz'ora ...


Questo strumento per .Net (bene C # solo ora) è StyleCop. code.msdn.microsoft.com/sourceanalysis
Bryan Anderson

15

La mia esperienza con la revisione del codice è che dovrebbe essere uno sforzo combinato per migliorare il codice, non una "misura" per decidere chi è bravo o cattivo nel loro lavoro. Quando non importa se ricevi molte osservazioni durante la tua revisione del codice, i revisori saranno più severi, dando così suggerimenti per migliorare il codice.

Per migliorare la qualità del codice registrato, imporre che i commenti di revisione vengano elaborati (lasciare che il revisore approvi i commenti elaborati) e utilizzare anche strumenti di controllo del codice statico per forzare un livello di qualità per il commit iniziale.


2
+1 per il tuo commento sul non lasciare che questo diventi un confronto tra chi è il migliore nel suo lavoro. Questo sarebbe male per il morale!

2
@KarstenF: True. Anche DeveloperA potrebbe lavorare con un'attività più complessa (più righe di codice) mentre DeveloperB potrebbe funzionare in un'attività semplice e potrebbe ottenere un punteggio inferiore (sulla scala dei punti). Non sarebbe giusto dire che DevA ha fatto un brutto lavoro quando non c'è modo di normalizzare entrambi i loro lavori / compiti

2
Inoltre alcuni sviluppatori potrebbero provare a screditare i propri colleghi.

questo punto è giusto. Concetti meschini (come la classificazione) portano alla meschinità.
Dan Rosenstark,

+1 su questo punto molto importante. Non appena il processo inizia a produrre un numero, le persone giocheranno il loro codice per aumentarne il numero. Scrivono molte righe di codice semplice, ad esempio, in modo che il loro punteggio di penalità / metodo sia molto basso. Oppure trascorrono tutto il loro tempo a trovare nomi di variabili perfetti. E poi diventa una cosa politica perché nessuno vorrà sottolineare piccoli errori nel codice del loro amico perché questo abbasserà il loro punteggio e li farà sembrare cattivi! Oh no! In breve, il tuo cuore è nel posto giusto, ma cattiva idea. I programmatori non sono cani da esposizione.
Leoger,

5

Penso che il tuo sistema di valutazione sia una cattiva idea. Qual è il punto? Per identificare i programmatori buoni e cattivi? Chiunque in quella revisione del codice può formulare una valutazione su un particolare programmatore in base al codice presentato nella revisione del codice meglio di qualche assegnazione arbitraria di valori a un insieme di caratteristiche in qualche modo arbitrario. Se vuoi identificare i programmatori buoni e cattivi ... chiedi ai programmatori. Garantisco che gli umani possano fare questa valutazione meglio del tuo sciocco euristico.

Il mio suggerimento sarebbe di provare a migliorare le revisioni del codice in modo che le persone condividano apertamente idee e opinioni in un ambiente non giudicante e non ostile. Se potessi farlo, starai 100 volte meglio dei giudizi sui programmatori basati sulle tue sciocche liste di controllo che pretendono di fare un buon lavoro di valutazione dei programmatori. Penso che molti programmatori siano già orgogliosi e duri con se stessi se fanno male nelle revisioni del codice; Mi chiedo se un'ulteriore "punizione" per prestazioni scadenti sia generalmente utile.


4

Il mio unico consiglio sarebbe di evitare di rendere il processo di revisione del codice troppo rigido : la cosa più importante è che la revisione del codice avvenga effettivamente e che sia presa sul serio .

Quanto più estenuante è il processo per il revisore, tanto meno è probabile che accadranno revisioni del codice e che saranno prese sul serio piuttosto che semplicemente considerate un fastidio. Inoltre, il vero valore delle revisioni del codice risiede nella capacità del revisore di utilizzare il proprio giudizio e gli strumenti automatizzati possono essere utilizzati per verificare cose come il passaggio delle regole FXCop.


100! Voglio dire, +1, ma in realtà non è questo il punto: per le revisioni del codice e i test unitari (e altre cose), meno è di più. Questo è vero solo perché di più è di più solo fino a quando diventa zero :)
Dan Rosenstark,

4

Come regola generale, evitare di passare qualsiasi momento in una revisione del codice facendo qualcosa che potrebbe essere fatto dalla macchina. Ad esempio, il tuo primo oggetto è "far rispettare le regole di FxCop", ma presumibilmente ciò può essere fatto da FxCop senza che anche gli umani debbano farlo.


3

Se riesci a misurarlo, se è obiettivo, quantificabile, allora prova a farlo fare da uno strumento. Dove hai bisogno di un recensore esperto è per le cose soggettive sfocate.


100 ore per realizzare lo strumento, 1000 salvate usando esso.
Dan Rosenstark,

3

Sono già stati fatti molti buoni commenti su questioni di stile, il che è importante. In un progetto di gruppo, è utile che tutto il codice sembri che sia stato scritto da un singolo autore. Questo rende più facile per gli altri membri del team entrare e risolvere i problemi quando si verificano. Quali misure quantitative scegliete per garantire questo obiettivo più ampio sono meno importanti.

Un ulteriore elemento è garantire che il codice corrisponda all'architettura generale concordata per il resto del sistema. Problemi simili dovrebbero essere risolti tutti allo stesso modo. Se la logica dell'applicazione è stata suddivisa su più livelli, il codice in fase di revisione suddivide la sua funzionalità come fa il resto del sistema? In alternativa, il codice in esame insegna qualcosa di nuovo che dovrebbe essere ritirato nel resto del sistema? Proprio come i controlli di stile assicurano che il codice abbia lo stesso aspetto, la revisione dell'architettura dovrebbe garantire che il codice funzioni allo stesso modo. L'enfasi è di nuovo sulla manutenibilità. Chiunque nel team dovrebbe essere in grado di entrare in questo codice e avere una comprensione di ciò che sta accadendo immediatamente.

L'idea di valutazione sembra un disastro in corso, ma conosci meglio la tua squadra. È possibile che siano motivati ​​da un tale sistema, ma penso che sia più probabile che le persone inizieranno a preoccuparsi più del loro grado che della risoluzione dei problemi. Uno degli effetti collaterali davvero preziosi delle revisioni del codice sono le opportunità di mentoring che offrono. Il revisore dovrebbe trattare la persona che ha scritto il codice come qualcuno che sta guidando. Ogni problema riscontrato non è un problema, ma un'opportunità per creare un membro del team più esperto e sofisticato e un team più affiatato nel complesso.


2

In realtà mi preoccupo più delle cose "soggettive" che di ogni altra cosa, francamente. Quello che voglio da una buona recensione del codice è qualcuno che controlli la mia logica, non la mia battitura. Ed è quello su cui mi concentro quando do una recensione del codice.

Il formato generale che mi piace prendere è:

  1. Cosa stiamo riparando?
  2. Cosa lo stava causando? (guarda il codice)
  3. Come lo stiamo risolvendo?
  4. Mostrami il nuovo codice
  5. Mostrami il codice funzionante

Senza questo, solo guardare le differenze tende a dare input su problemi minori o punti stilistici. Sono molto più preoccupato se la logica è corretta, l'approccio usato nel complesso è buono e se la soluzione sarà mantenibile.

Ad esempio, di recente ho esaminato un codice da parte di un collega. Il problema originale era una violazione di FxCop. Ma ciò che veniva fatto era tentare di determinare la presenza o l'assenza di una funzionalità di Windows controllando il numero di versione. Il mio input principale è stato che questo era un modo fragile per farlo, e sarebbe meglio interrogare direttamente il servizio, poiché la mappatura tra l'esistenza delle funzionalità e lo sku di Windows potrebbe cambiare in futuro e non era affatto a prova di futuro.


Non chiaro dalla tua risposta: FxCop ha catturato quella fragilità o hai fatto?
Dan Rosenstark,

2

La complessità ciclomatica (CC) è un modo per valutare il codice "non male".

Nel codice attuale che ha un alto CC, ho un alto fattore "cosa sta succedendo qui, non ricordo". Il codice CC inferiore è più facile da capire.

Ovviamente, si applicano le solite avvertenze per le metriche.


1
@AfermeraInfo: eh?
Paul Nathan,

1

Le revisioni del codice sono sia soggettive che oggettive. Regole come "il corpo del metodo deve essere di 20-30 righe" sono soggettive (alcune persone potrebbero pensare che 100 righe siano OK) ma se la tua azienda ha deciso che il limite è 20-30 righe, va bene e puoi misurarlo. Penso che il sistema di punti che hai ideato sia un'ottima idea. Dovrai rivalutarlo periodicamente poiché scopri che alcune regole devono avere più o meno peso nel punteggio, ma finché tutti conoscono le regole, sembra un buon sistema.

Altre cose che vorrei cercare:

  • chiarezza del codice - a volte un pezzo di codice può essere scritto in una o più righe. Il programmatore medio non dovrebbe passare diversi minuti a cercare di capire cosa fa una riga di codice. Se lo fa, forse il codice dovrebbe essere riscritto in un modo più semplice. Questo è soggettivo ma il punto chiave è che il codice dovrebbe essere immediatamente comprensibile dalla maggior parte dei programmatori della tua azienda.
  • controlla i parametri di input della funzione - dovrebbe esserci del codice per verificare che i parametri di input rientrino in intervalli accettabili. Questo dovrebbe corrispondere anche alla documentazione della funzione.
  • nomi delle variabili descrittive - tranne in alcuni casi speciali (indici di loop, ecc.), i nomi delle variabili dovrebbero essere descrittivi. Una risorsa che potresti voler dare un'occhiata alle convenzioni di denominazione, ecc. È il codice completo

1

Sembra che tu stia diventando troppo dettagliato troppo in fretta. Dovresti scomporlo di più. È necessario osservare il codice per la sua qualità del codice e per la conformità delle sue funzionalità. Avresti dovuto separarli entrambi e non è nemmeno la fine della storia ... quindi ecco il mio suggerimento:

Qualità del codice:

  • Controlli automatizzati:
    • Conformità dello stile: la convenzione di denominazione è corretta, tutti i codici sono rientrati correttamente, ecc.
    • Standard di efficienza: verifica perdite di memoria, controllo complessità, variabili ridondanti, ecc.
  • Revisione tra pari effettiva:
    • Una semplice passeggiata nel design
    • spiegazione delle deviazioni dai controlli automatizzati
    • Facilità di manutenzione, parla di come puoi mantenerlo e tutto il resto
    • Testabilità: quanto è facile testare questo codice? Hai un piano?

Conformità delle funzioni:

  1. Una revisione dei requisiti delle funzionalità e di eventuali modifiche rispetto ai requisiti e / o alla revisione del progetto
  2. Dimostrare la funzionalità associata ai requisiti e verificarli uno per uno
  3. Discutere di eventuali requisiti aggiuntivi negli altri aspetti del software riscontrati durante l'implementazione (come piani di implementazione, infrastruttura, ecc.)
  4. Spiegazione di eventuali deviazioni dai requisiti, se del caso a quel punto.

Se riesci a coprirti su questi due aspetti di una revisione del codice, sei d'oro.



1

Dipende.

Alcune parti della recensione sono facilmente quantificabili (nessun problema FxCop, nessun errore StyleCop , nessun errore CAT.NET , ecc.)

Lo stile, tuttavia, può essere soggettivo, ma come dici tu, una volta che inizi a essere più specifico (nessun metodo> 20 linee), puoi misurarlo e strumenti come NDepend possono farlo automaticamente. Tuttavia, alcune cose non saranno mai automatiche: il controllo della gestione dei casi limite richiederebbe dei test per farlo, il che porta alla copertura del codice e il 100% è un ideale irraggiungibile in molti casi. Il controllo di duplicazione è difficile da eseguire automaticamente. Controlli nulli, non sono sicuro che io sia d'accordo con te, ma potresti essere in grado di scrivere regole NDepend o FxCop per quella.

Maggiore è il numero di strumenti, meglio è, e se gli strumenti consentono agli sviluppatori di verificare il proprio lavoro prima di apportare modifiche e di eseguire i controlli come parte del processo CI , minimizzerete la necessità di revisioni.


0

Un sistema di marcatura sembra complicato da ottenere, ma vale la pena di avere uno strumento di misurazione: non puoi migliorare ciò che non puoi misurare. Ma dovresti probabilmente accettare che alcune cose saranno difficili / impossibili da quantificare accuratamente. La cosa difficile sarà capire quanti punti ogni punteggio di qualità dovrebbe avere: per esempio, se aderire alle convenzioni di denominazione ottiene 2 punti, allora quanti punti per mantenere piccoli i metodi?

Forse qualcosa come una semplice lista di controllo sarebbe meglio, in modo che il codice possa essere contrassegnato come conforme, parzialmente conforme o non conforme a una particolare qualità. Successivamente, puoi aggiungere un punteggio all'elenco di controllo quando vedi quali problemi di qualità emergono più spesso o causano la maggior parte dei problemi.

Il processo di revisione dovrebbe anche essere abbastanza flessibile da consentire al codice di fallire parti della revisione, a condizione che ciò possa essere giustificato e documentato. È una cattiva idea attenersi ciecamente ad alcuni standard di qualità del codice che rendono un componente inutilmente complesso / ingestibile!


le cose perfette accadono.

0

Se vuoi che il codice delle persone sia più standardizzato, senza farli "perdere tempo nella formattazione", come si lamentano alcuni sviluppatori. Investi in uno strumento come ReSharper in quanto rende il processo di correzione della formattazione e altre attività di factoring un processo quasi automatizzato.


0
  • Se una macchina può controllarlo, le persone non dovrebbero.
  • Un solo elemento della checklist: ogni caso di errore è gestito correttamente ovunque?
  • Utilizzare le revisioni del codice per migliorare la qualità e trasferire le conoscenze.
  • Non utilizzare le revisioni del codice per identificare gli sviluppatori "cattivi".
  • I segni dell'ego sono più efficaci dei punti espliciti.
  • Tienilo breve: 90 minuti e 500 linee sono ENORMI.
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.