I programmatori junior dovrebbero essere coinvolti come revisori dei codici nei progetti di programmatori senior?

Uno dei membri del mio team, un programmatore junior, ha notevoli capacità di programmazione per il suo livello di esperienza.

E durante le revisioni del codice, credo nell'enfatizzare l'apprendimento, non nel sottolineare errori.

Ma i programmatori junior dovrebbero essere coinvolti nelle revisioni del codice per programmatori più senior? O le recensioni sui codici dovrebbero essere frequentate solo da programmatori con esperienza corrispondente?

Lo scopo principale di una revisione del codice è trovare difetti o potenziali problemi. I partecipanti richiesti alla revisione dovrebbero essere le persone più adatte a identificare questi problemi, indipendentemente dal loro titolo o anzianità.

Ad esempio, se un'applicazione è in fase di sviluppo in Python e l'ingegnere junior ha più esperienza con il linguaggio Python rispetto all'ingegnere senior che ha scritto il codice, allora potrebbero essere una risorsa preziosa nel sottolineare metodi alternativi di fare qualcosa, ma loro potrebbe anche avere una conoscenza minore del sistema nel suo insieme.

Oltre all'esperienza negli strumenti e nelle tecnologie, considera anche l'esperienza nel dominio dell'applicazione. Qualcuno con 20 anni di esperienza ma solo 1 o 2 nel settore finanziario può essere aiutato dal fatto che uno sviluppatore complessivamente meno esperto con solo 5 anni di esperienza tutti nel settore finanziario riesaminasse il suo lavoro.

Invitare membri dello staff meno esperti a osservare e partecipare il più possibile al processo di revisione del codice può anche essere utile per consentire loro di apprendere una base di codice, porre domande e conoscere ciò che ci si aspetta da loro non solo nelle revisioni del codice, ma nella codice che producono. Tuttavia, probabilmente non vuoi coinvolgere troppe persone (concentrandoti invece sulle persone che possono supportare pienamente la revisione del codice e il suo scopo) nel processo.

Questo vale davvero per qualsiasi tipo di revisione: requisiti, design, codice ...

I programmatori junior dovrebbero essere coinvolti come revisori del codice nei progetti di programmatori senior?

Sì dovrebbero. È una buona esperienza di apprendimento leggere il codice di altre persone. (E questo vale sia per il buon codice che per il cattivo. Sebbene si possa sperare che il codice di uno sviluppatore senior non sia cattivo ...)

Ovviamente, non è saggio che solo i giovani eseguano la revisione del codice. E non è saggio porre aspettative troppo alte sui giovani in termini di ciò che possono trovare. Tuttavia, potresti anche essere sorpreso dalle nuove intuizioni che i programmatori junior possono portare al tavolo.

Un'altra risposta menzionava che i giovani erano / si sentivano intimiditi. Questo NON è ciò di cui la revisione del codice dovrebbe riguardare ... né i revisori né i revisori. Se ciò accade, il tuo gruppo deve cambiare il modo in cui esegue le revisioni del codice ... e forse gli intimidatori devono essere messi in riga.

Vorrei aggiungere che se un programmatore "Junior" non è in grado di capire un codice per gli anziani, questo è di per sé una buona misura del codice. OK ci possono essere momenti in cui non è possibile scrivere codice che tutti possano capire, ma si spera che siano eccezioni: se solo 1 o 2 persone possono capire il codice, cosa succede quando quelle persone non sono disponibili e c'è un problema con vero?

Dare alle persone nuove sfide le aiuta a svilupparsi; potrebbe anche essere che non tutti siano tagliati per la revisione del codice, ma sembra dogmatico insistere sul fatto che qualcuno abbia un titolo ( determinato dalla politica e dai giochi delle risorse umane ) prima di essere idoneo ad aiutare in una recensione.

Come altri hanno sottolineato, una revisione del codice può essere un processo a due vie; aiuta tutti a comprendere la base di codice, quindi condivide le conoscenze, aiuta i giovani a imparare modi e tecniche nuovi e migliori dai loro anziani e aiuta gli anziani a perfezionare la loro comprensione e scrivendo per assicurarsi che tutti possano seguire il codice che hai più occhi che possono cogliere errori.

Lo scopo delle revisioni del codice è quello di rilevare i problemi che i test non possono rilevare, come i problemi di manutenibilità e casi angolari. Direi che in molti modi i programmatori junior sono più adatti a questo scopo:

• Hanno più tempo a disposizione in generale.
• È più probabile che lo prendano lentamente, riga per riga, per necessità per capire il codice.
• Quando parli della possibilità di mantenere il codice, ciò significa che tutti all'interno dell'azienda, non solo i tuoi programmatori principali. Ciò significa che i programmatori junior devono essere in grado di comprendere il codice per dichiararlo mantenibile.
• Spesso hanno meno probabilità di fare cattive assunzioni, confidando che qualcosa funzioni nel modo in cui suppongono che dovrebbe funzionare.
• La loro istruzione in un linguaggio di programmazione è più recente e ha meno probabilità di essere confusa con anni di esperienza in un'altra lingua. Ad esempio, un anziano potrebbe accidentalmente usare un'abitudine che ha preso dal C ++ che compila ma funziona in modo leggermente diverso in Java. I giovani rilevano più facilmente questo tipo di errori.
• I revisori dei codici devono solo identificare i problemi, non necessariamente proporre una soluzione migliore. Spesso faranno commenti sulla falsariga di "Non riesco davvero a capire come farlo meglio, ma questa parte è davvero confusa a causa di tutta la ripetizione". Un programmatore più esperto può quindi apportare facilmente i miglioramenti anche se all'inizio non hanno notato il problema.

Questo non vuol dire che non ci sono altri modi in cui i programmatori senior sono più adatti a fare recensioni, ma il mio punto è che stai facendo un disservizio se non stai sfruttando appieno la diversità della tua squadra.

Ai giovani verrà spesso chiesto di mantenere il codice, è fondamentale che possano capirlo.

A volte i junior sono le uniche persone disponibili a rivedere il codice degli sviluppatori senior. Il codice dovrebbe aspettare per passare al QA (non eliminiamo nulla dallo sviluppatore senza una revisione del codice e presumo anche questo tipo di revisione del codice) perché il capo dell'anziano è in vacanza?

Ho anche chiesto espressamente ai giovani di ripassare un codice quando sapevo che avrebbero fatto qualcosa di simile per un cliente diverso a breve o se avessi saputo che avevano lavorato su qualcos'altro simile o che avevano un determinato set di abilità.

Se il codice è abbastanza semplice, spesso riesco a fare una recensione a una persona più giovane. Perché perdere il tempo della persona anziana se la persona più giovane è abbastanza capace di fare il lavoro? Se i ragazzi si sentono intimiditi dalla revisione del codice senior, inducili a guardare inizialmente i pezzi più facili. Dopotutto non riesci a superare l'essere junior fino a quando non smetti di sentirti intimidito.

Ho spesso scoperto che se dovessi spiegare il codice a una persona più giovane che non lo capisce, vedrò un errore che ho fatto (di solito in un presupposto) e che nessun revisore esperto del codice avrebbe rilevato perché il codice viene eseguito ma non fa esattamente quello che era previsto. Quindi solo l'atto di spiegare le cose spesso aiuterà lo sviluppatore a vedere un problema senza che il revisore del codice lo trovi. Dal momento che le persone più esperte non vengono spesso seguite passo passo dal codice, questi tipi di cose si trovano più facilmente quando un junior fa la revisione.

Trovo che avere minori coinvolti nelle recensioni abbia diversi effetti positivi. Innanzitutto li rende più sicuri quando riescono a capire il codice di una persona anziana. Li rende ancora più sicuri quando riescono a trovare un bug in quel codice.

Li espone a processi di pensiero al di fuori dei propri e consente loro di vedere altri modi di gestire le cose. Anche da senior, questo è successo a me: vedere un modo diverso di risolvere un problema può aprire gli occhi a nuove possibilità.

Li aiuta a imparare a leggere il codice di altre persone e dà loro la possibilità di chiedere cosa sta facendo il codice mentre è ancora fresco nelle menti dell'autore. È molto meglio che dover mantenere la cosa sei mesi dopo, quando l'autore è scomparso da tempo o è impegnato in un altro progetto e non ha tempo per le domande.

È positivo per gli anziani perché entrambe le domande espongono potenziali aree in cui il minore è debole e ha bisogno di tutoraggio (in modo che possano assumersi maggiori responsabilità e dare agli anziani più tempo per svolgere altri tipi di attività) o aree in cui il codice non è semplicemente chiaro chiunque tranne l'autore (il che significa che potrebbe non essere nemmeno chiaro all'autore tra un anno da quando è necessario cambiarlo). Aiuta anche gli anziani a rendersi conto che gli junior potrebbero essere più intelligenti di quanto non stiano dando loro credito. Aiuta a mantenere tutti su una base professionale. Dopotutto, se si escludono i giovani, si sta chiaramente insinuando che non si pensa che siano in grado di comprendere il codice che è psicologicamente sfortunato.

I giovani che esaminano il codice degli anziani possono generare più rispetto professionale nella tua organizzazione. Gli anziani potrebbero rendersi conto di aver sottovalutato i giovani e i junior potrebbero rendersi conto che gli anziani sanno più di quanto non gli abbiano dato credito. I giovani a volte pensano di avere abilità più grandi di loro. Essere esposti al codice che non possono scrivere è un bene per queste persone perché iniziano a rendersi conto che hanno molto di più da imparare. Inoltre stimolerà il meglio di loro per acquisire le abilità. A scuola a volte gli studenti B non capiscono perché non hanno ottenuto una A fino a quando qualcuno non mostra loro un campione del livello A di lavoro. Lo stesso vale per i giovani agli anziani nella revisione del codice.

La mia risposta è: a volte . Varia da programmatore a programmatore e da un'attività all'altra.

Per:

• Se vuoi che quei ragazzi imparino come fare una revisione efficace del codice, allora il modo migliore per loro è vedere come lo fanno gli anziani.
• Un programmatore junior potrebbe avere più esperienza di un senior in una particolare lingua / dominio / ecc.
• Costringendo i giovani a valutare il codice degli anziani, inevitabilmente impareranno le cose. La programmazione a coppie sarà un modo più efficace per farlo, poiché qualsiasi domanda che il minore può avere può ottenere risposte immediate.
• Il codice di nessuno è sacro e nessuno è così bravo che il suo codice non dovrebbe essere rivisto. Se non lo fai, chi rivedrà il codice dei tuoi migliori ragazzi?
• Non tutti i giovani sono uguali e non tutti gli anziani sono uguali. A volte potrebbe non esserci un grande divario, quindi non rimanere impigliato nei titoli di lavoro.

Contro:

• Esiste il rischio che le recensioni vengano impantanate a causa di problemi da parte di minori.
• Il livello di conoscenza / abilità richiesto potrebbe semplicemente andare oltre le capacità del junior. Questo non solo perderà il loro tempo, ma molto probabilmente demoralizzerà anche loro.

Sono fermamente convinto che tutti i membri del team dovrebbero essere coinvolti su entrambi i lati delle revisioni del codice. I junior dovrebbero rivedere il codice senior e viceversa. Perché entrambi? Perché di solito non si tratta solo se il codice "risolve il problema". Non posso dirvi quante volte ho dovuto spiegare un pezzo di codice a qualcuno e improvvisamente trovare un modo molto migliore di farlo entro la fine della spiegazione. Le revisioni del codice hanno probabilmente 3 scopi:

1. Assicurarsi che il codice sia corretto
2. Fai in modo che lo scrittore pensi a come gli altri vedranno il loro codice
3. Ottieni il feedback del lettore su cosa potrebbe essere migliorato e un secondo paio di occhi generale

Sono un minore e rivedo comunemente codice scritto senior. È una politica aziendale generale "ogni cosa viene revisionata da qualcuno". Imparo molto da questi riesaminando il loro codice e avendo l'opportunità di porre domande sul perché le cose vengano fatte in un certo modo. E a volte, propongo un modo più pulito per fare un certo pezzo di codice e simili. Molto più raro delle persone che mi dicono come migliorare il mio codice, ma è successo almeno una volta.

È anche importante quanto siano formali le tue recensioni di codice. I nostri sono molto informali e consistono in "ehi guarderai il mio codice" che viene detto attraverso cubicoli o in un canale IRC privato. Potrei immaginare che se rivedete il codice in un contesto più formale, il minore sarebbe probabilmente molto più interessato a rivedere il codice di un anziano.

Assolutamente, gli ingegneri junior dovrebbero rivedere il codice degli ingegneri senior, almeno qualche volta.

Nella mia esperienza, è piuttosto raro che il revisore in una revisione del codice uno-a-uno in realtà veda un errore che manca al programmatore originale, sia che il revisore sia senior o junior; il recensore non deve nemmeno essere umano . È molto comune, d'altra parte, che il programmatore originale riconosca un errore nel tentativo di spiegare il codice e più giovane è il revisore, più è probabile che ciò sia dovuto alla profondità della spiegazione richiesta.

A mio avviso, alcuni vantaggi più spesso trascurati della revisione del codice sono forse più importanti nel lungo periodo rispetto alla rilevazione di errori:

• Condividere la conoscenza di ciò che sta realmente accadendo nella base di codice - "Aspetta, penso che Bill avesse una classe che fa X, non abbiamo bisogno di scriverne una nuova."
• Condivisione della conoscenza di buone tecniche e stile di programmazione.

In entrambi questi aspetti, un revisore junior tende a beneficiare di più di un senior.

I programmatori junior dovrebbero assolutamente eseguire revisioni del codice per i loro colleghi senior!

Tuttavia, non dovrebbero essere l'unico recensore . Associarli a uno sviluppatore più esperto per revisione del codice.

Ci sono una miriade di vantaggi:

• L'autore sarà costretto a spiegare di più del proprio codice. Parlare attraverso il tuo codice è uno dei modi migliori per trovare problemi con esso, o modi migliori per farlo.

• L'autore troverà punti deboli nel proprio codice. Lo sviluppatore junior ha maggiori probabilità di essere confuso da alcuni dei pezzi più avanzati. Spesso sono "troppo complicati" per il loro bene e potrebbero trarre vantaggio dalla semplificazione.

• Lo sviluppatore junior imparerà migliori pratiche di codifica. Le revisioni del codice sono un'opportunità per insegnare con l'esempio.

• Lo sviluppatore junior sarà un revisore del codice più efficace. La revisione del codice è difficile . Più tutti hanno esperienza con le revisioni del codice, più veloci ed efficaci diventano le revisioni del codice.

• Lo sviluppatore junior avrà una conoscenza più profonda della base di codice. Sii egoista! Attirando gli sviluppatori junior in anticipo, sarai in grado di consegnarli a loro prima.

• Lo sviluppatore junior si sentirà più coinvolto. Lo sviluppatore junior inizierà a vedere il codice "senior" (e i loro colleghi) come meno straniero e intimidatorio. Questo è un vantaggio enorme e spesso trascurato delle revisioni del codice.

• Lo sviluppatore junior è una nuova serie di occhi. Non sono indottrinati come qualcuno che ha lavorato sulla base di codice per un lungo periodo di tempo. È più probabile che lo sviluppatore junior indichi diversi modi di realizzare le cose mentre fanno domande. Non scrollarti di dosso i loro commenti più selvaggi senza almeno qualche considerazione!

• Gli sviluppatori senior sono ritenuti responsabili. Ho visto spesso situazioni in cui gli sviluppatori senior tendono a sorvolare il codice degli altri (fiducia, pigrizia, ecc.). Un ulteriore set di occhi aiuta a scoraggiarlo.

Il rovescio della medaglia da considerare è che tutte le parti coinvolte impiegheranno un bel po 'di tempo a eseguire revisioni del codice. Pertanto, può essere un po 'difficile vendere al management. Tuttavia, i benefici superano completamente il ritmo più lento.

Viene eseguita una revisione del codice per la revisione del codice, non per l'apprendimento. Se fossi un programmatore junior, sarei intimidito a rivedere il codice senior.

D'altra parte, leggere il codice per senior è un ottimo modo di apprendere, a condizione che il Senior sia disponibile per rispondere a tutte le domande.

Due alternative potrebbero essere:

• lasciare che Juniors partecipi alle riunioni di revisione del codice e che ogni partecipante sia aperto a discussioni di insegnamento / apprendimento
• programmazione di coppie di pratica