Quanto è importante ripulire il codice di qualcun altro di fronte a una scadenza serrata? [chiuso]


38

(Sto parlando di codice HTML / CSS (non di linguaggi di programmazione) ma penso che dovremmo affrontare lo stesso problema dei programmatori.)

Sono il progettista senior di front-end in una squadra e spesso devo rielaborare la produzione dei miei junior in tempi ristretti.

Sono di fronte a 2 problemi:

  1. Il loro stile di programmazione è un po 'un casino.
  2. L'estetica non è buona.

Il loro stile di codifica, trovo, è un miscuglio senza convenzioni / standard adeguati. Sono combattuto tra ripulire il codice o semplicemente occuparmi del loro codice (anche copiando come fanno le cose).

Trovo frustrante seguire il loro stile di programmazione perché sento che potrei imparare cattive abitudini. Ma poi, questo è il modo più veloce per rispettare la scadenza.

Per quelli con molta più esperienza, quale è più efficace? Devo salvare la pulizia per dopo? O ripulire lungo la strada mentre apporto le modifiche?

(Non voglio sembrare arrogante, ma tale è la realtà. Ci vorranno più anni per scrivere un codice migliore. Lo so, ho scritto un codice disordinato quando stavo iniziando.)


1
Se hai l'opzione, dai un'occhiata ai prodotti JetBrains (Re-Sharper per C #, IntelliJ per Java e persino alcuni linguaggi 'dinamici') che possono apportare cambiamenti idiomatici a livello di progetto a livello di soluzione, con un investimento di tempo molto ridotto. (Può anche essere usato per insegnare in modo interattivo ai giovani ciò che è idomatico. Ma assicurati che tu e loro concordino le stesse impostazioni per il progetto. (E assicurati di fare tutte quelle cose in un commit separato, quindi non mescolare cambiamenti sostanziali e cosmetici nello stesso impegno),
David Bullock


2
Implementare una guida di stile / minimanual? Voglio dire, non scriveranno codice migliore , ma tutti sono in grado di seguire le linee guida che richiedono di scrivere cose banali in un unico modo particolare.
Peteris,

10
Vedo già che hai un problema con la mancanza di lavoro di squadra qui. Dovresti educare e nutrire il giovane; non solo riscrivere il suo codice e lamentarsene.
James,

3
@Ramhound da quando Turing ha ideato la Turing Machine immagino. Ma torniamo al punto, se sei l'anziano che dovrebbe convincere i giovani ad ascoltarti. Insegnate loro come fare nel modo giusto (o nella convinzione). Ma è importante chiedere la loro opinione e forse hanno qualche idea su come fare le cose in un modo migliore. Inoltre, se stai utilizzando CSS non elaborati per qualsiasi progetto non banale, stai sbagliando, prova a far sì che il tuo progetto adotti LESS o SASS.
Hoffmann,

Risposte:


79

Credo che tu stia guardando il problema nel modo sbagliato - ti stai perdendo una grande opportunità di insegnare ai giovani come scrivere codice migliore.

Se riscrivi abitualmente il loro codice, potresti dare ai tuoi ragazzi l'impressione di non apprezzare il loro lavoro, il che ridurrà il loro morale e non li aiuterà a programmare meglio la prossima volta.

Un approccio migliore, credo, è quello di aggiungere al processo di sviluppo del tuo team un'attività di revisione del codice. Non deve riguardare ogni parte del codice impegnato e non deve (direi che non dovrebbe) essere condotto solo da te - ogni volta che un membro del tuo team termina un compito abbastanza grande, dovrebbe accoppiare con uno (o più) dei suoi compagni di squadra, spiegare loro il codice e ricevere opinioni e critiche costruttive sul suo design, stile di programmazione, possibili bug e problemi di sicurezza, ecc.

Quando sei il compagno di squadra per la revisione del codice, impareranno dalle tue competenze molto di più rispetto a quando riscrivi semplicemente il loro codice (hanno la possibilità di sentire il motivo per cui il codice dovrebbe essere cambiato) e potrebbero offendersi meno.

Dare loro la possibilità di condurre anche revisioni del codice migliorerà ulteriormente le loro capacità - vedendo come le altre persone scrivono il codice e perché - e aumenterà la loro autostima.

Impareranno anche molto se darai loro la possibilità di rivedere il tuo codice. Potresti imparare qualcosa anche tu, quindi non farlo solo per spettacolo!


Sono d'accordo al 100% con te, tuttavia mi chiedo come applicarlo in presenza di scadenze ravvicinate. Suggerisci di fare revisioni del codice anche se potrebbero risucchiare più tempo prezioso (sia nel processo di revisione che nelle correzioni apportate dopo la revisione)?
Phil

3
Non penso che un membro del team debba modificare il lavoro di un altro membro del team senza la sua collaborazione / consenso. La persona che ha scritto il codice dovrebbe esserne responsabile e, a meno che il codice non contenga un bug critico e lo scrittore originale non sia disponibile, avere un programma stretto non è un motivo per cambiare il codice di qualcun altro. Se trovi il codice troppo disordinato, comunicalo allo sviluppatore e digli di ripulirlo per la prossima versione.
Uri Agassi,

23
@Phil Nel calcolare una scadenza, è necessario prendere in considerazione il tempo per le sessioni di revisione del codice. Non è un ulteriore passo in cima al processo di sviluppo: è parte integrante del processo di sviluppo.
dj18

2
Inoltre, l'addestramento dei giovani tramite la revisione del codice può avere un certo tempo (ora come dice dj18 dovrebbe essere preso in considerazione per le scadenze e le stime comunque) ma sarà rimborsato a tempo debito molte volte mentre ti libera di fare lavoro più originale. Se le tue scadenze sono così strette che non hai mai la possibilità di farlo, odora piuttosto di una spirale mortale ...
Julia Hayward

2
@JustinPaulson non fraintendetemi: il fatto che qualcuno abbia scritto del codice non lo rende "suo". Una settimana dopo un altro membro del team otterrà un'attività che le richiederà di modificare quel codice, e sicuramente dovrebbe cambiare il codice per le sue esigenze. Tuttavia, non vedo un caso d'uso in cui qualcuno dovrebbe "ripulire" il codice di qualcun altro per motivi di ripulitura, soprattutto non come una cosa dell'ultimo minuto in una scadenza serrata.
Uri Agassi,

29

L'ho già detto e lo ripeterò "il codice di lavoro è più prezioso del codice carino".

Se si modifica il codice, è molto probabile che si cambi il suo comportamento, se si tratta di un codice testato, si è appena annullato tutto lo sforzo di test e sarà necessario ripetere i test.

Incoraggia sicuramente i tuoi ragazzi a scrivere un codice comprensibile, ma se riscrivi tutto ciò che scrivono, allora stai sprecando denaro più volte dai tuoi datori di lavoro. Devono pagare per i tuoi junior, quindi pagare per te per fare quello che hanno già pagato per i tuoi juniors, e poi pagare per te ancora una volta per fare il lavoro che ti hanno effettivamente assunto.


11
"se questo è un codice testato, hai appena annullato tutto lo sforzo di test e dovrai ripetere i test." No, non hai invalidato nessuno sforzo di test. Dovrai solo rieseguire i test, che dovresti comunque fare per ogni commit. Se ciò richiede così tanto tempo che è considerato impossibile, i test sono una schifezza e dovrebbero essere riparati.
l0b0

7
Vale la pena notare che scrivere continuamente codice sciatto per "farlo funzionare" porterà a una grande palla di fango . Va bene se è un'eccezione e non la regola. Se diventa la regola, dovresti parlare con il tuo capo che le scadenze non sono l'unica cosa da considerare.
Neil

20
Il problema è che il brutto codice si trasforma rapidamente in codice rotto.
Telastyn,

1
@ramhound - certo, ma l'OP (e quasi tutti gli altri) non sta parlando di codice che sta semplicemente usando vecchi standard - sta parlando di codice scomodo, incoerente, scadente.
Telastyn,

1
@JamesAnderson Questa è una prospettiva estremamente miope. Il codice viene scritto una volta ma viene mantenuto per l'intera vita del prodotto. La maggior parte della codifica è refactoring. Per quanto tempo stai effettivamente scrivendo il codice su uno schermo vuoto prima di modificarlo e vedere se funziona come previsto? Quindi stai effettuando il refactoring, anche nella prima ora dopo l'inizio di una nuova lezione. Il costo del refactoring del brutto codice nelle successive correzioni di bug e miglioramenti supererà il costo di un po 'di tempo speso in anticipo con le revisioni del codice e spostando il team verso uno standard chiaro.
Scott Shipp,

16
  • La risposta breve è: no. Quando i tempi sono difficili, a volte devi solo abbassare la testa e prendere il proiettile estetico. ;)

  • Una risposta più pragmatica è timbrarla. Budget un'ora per eseguire e ripulire un aspetto specifico del codice. Quindi controllalo e fai un vero lavoro. Ma sii onesto con te stesso riguardo al mantenerlo vincolato.

  • A volte, tuttavia, un po 'di pulizia rende il lavoro più veloce. Anche alcune rapide modifiche al tipo di ricerca e sostituzione rendono tutto molto più accessibile.

  • Diffidare di guerre di stile. Soprattutto in una situazione a scadenza ravvicinata, se hai intenzione di annullare alcune preferenze stilistiche che l'altro programmatore rifarà, allora di nuovo è meglio aspettare fino a quando non hai il tempo di capire davvero come vuoi affrontare quelle questioni stilistiche in modo cooperativo. (Il che significa che alcuni danno e prendono).

Ma c'è un valore di giudizio nella risposta. Direi "moderatamente" importante. Il codice pulito può davvero velocizzare il lavoro e, dopo tutto, la qualità del codice fa parte del risultato finale. Non credo di poter toccare il codice (anche il mio) senza spendere un po 'di tempo per la pulizia. Ma assicurati che agitarsi con lo stile e il formato e le guerre di stile, non diventi più importante che portare il codice in produzione.


9

Quando correggo il codice e ho una scadenza, utilizzo normalmente due regole:

Il codice è terribile, ma è possibile trovare un problema in tempo ragionevole e risolverlo

Risolvo un problema e lasciavo il resto intatto .

Il codice è così disordinato che è davvero difficile trovare un problema lì. Riparare qualcosa causa immediatamente le interruzioni di qualcos'altro. Probabilmente sarebbe più veloce scrivere quel codice da zero piuttosto che ripararlo.

Quindi non ho altra scelta che riscrivere / refactor fino a quando il codice non sarà abbastanza pulito da localizzare e correggere il bug.

Il caso limite è:

Il codice è disordinato e davvero pessimo. È ancora possibile correggere un bug in tempi ragionevoli, ma la struttura del codice renderà molto difficile la manutenzione. È molto probabile che qualsiasi nuova funzionalità introduca nuovi bug o causi una riduzione significativa delle prestazioni.

In tal caso, il codice deve essere corretto, ma solo quando devono essere implementate nuove funzionalità, attivate durante il tempo di inattività, mai nel tempo di correzione dei bug di fronte alla scadenza!


Il problema con il "caso limite" è che altri moduli tendono a spuntare e fanno uso di quel codice. Diventa quindi molto rischioso cambiare poiché altri moduli possono ora fare affidamento su un comportamento "errato / indesiderabile". Quindi ti ritrovi bloccato con un codice che è davvero difficile da mantenere che ti fa rabbrividire ogni volta che lo vedi e ti fa venire voglia di andare altrove per lavoro. Come minimo, il codice errato deve essere bloccato da qualcuno che sa cosa sta facendo. In questo modo, può essere risolto in un secondo momento senza correre il rischio di lasciarlo finché qualcuno non ha il tempo di aggirarlo.
Dunk

6

Sarei interessato a sapere a che punto del tuo processo stai riscontrando questo problema?

A rigor di termini, in questo magico mondo ideale in cui nessuno di noi abita, tutto il codice promosso o distribuito dovrebbe essere perfetto. Non è così a volte devi essere pragmatico.

Tuttavia, se si dispone di un processo di revisione del codice, è necessario evidenziarlo prima del test. Se sei costantemente contro le scadenze, i problemi con le stime per la consegna significano che una componente chiave di qualsiasi processo di sviluppo - ovvero la revisione del codice - viene strangolata?

I tuoi ragazzi non impareranno mai a sedersi e ad assorbire modi migliori di fare le cose se non ti prendi il tempo di renderlo parte del loro processo di sviluppo per imparare. Mi sembra che tu non lo stia facendo.


4

Dipende dalla cultura generale. Se scadenze strette sono sporadiche, accetta che dovrai fare le pulizie in seguito. Se sono costanti, allora stai strutturando strutturalmente il debito tecnico e dovresti affrontare il problema con la gestione. Se non rispondono alle tue preoccupazioni, è meglio iniziare a cercare altre opportunità di lavoro, poiché la cultura aziendale molto probabilmente incontrerà presto i principi darwiniani.


3

Al fine di aiutare a risolvere il problema in futuro, sviluppare un documento interno sugli standard e le pratiche di codifica che tutti i dipendenti devono seguire.

Per il batch corrente, ripulisci il codice in base al documento S&P mentre esegui il refactoring del codice, ma solo durante il refactoring.


Ho lavorato per alcune grandi aziende orientate al processo che erano disposte a spendere soldi incredibili per garantire il rispetto degli standard e delle pratiche di codifica. NON SONO MAI STATI MAI finché gli strumenti automatici non hanno iniziato a farli rispettare.
Dunk

@Dunk L'esercito americano conta come "grande e orientato al processo"? Usano sempre S & Ps: stroustrup.com/JSF-AV-rules.pdf
Casey

Sicuramente contano come il gold standard per gli standard e le pratiche di codifica. Ogni contratto li richiede. Tuttavia, per quanto le aziende provino ad aderire ai loro standard e alle loro pratiche, ciò non avviene in modo affidabile e coerente. Sta succedendo troppo. Ecco perché sono necessari strumenti automatizzati se vuoi includere la parola "must" nel tuo suggerimento, come hai fatto tu. Il DOD ha riconosciuto l'impossibilità di aderire agli standard con mezzi manuali ed è per questo che il Congresso ha approvato una legge nel 2011 che impone agli appaltatori della difesa di iniziare a utilizzare strumenti automatizzati per eseguire questi controlli.
Dunk

A proposito, non sto dicendo che non siano necessari standard e pratiche di codifica. C'è assolutamente bisogno. Ho solo una contesa con la parte "tutti i dipendenti devono seguire", a meno che tu non menzioni anche qualcosa sull'applicazione di questo tramite strumenti automatici.
Dunk

@Dunk Il team JSF-AV deve averlo riconosciuto, il documento menziona specificamente l'uso di strumenti automatizzati come modo per far rispettare l'S & Ps (nel 2005)
Casey

2

Sono abbastanza inesperto con la programmazione. Come studente, tuttavia, mi impegno spesso a rivedere i colleghi e collaborare ai progetti. Se c'è molto tempo per finire un progetto, andrò avanti e ripulirò il codice di un membro del team per chiarezza e leggibilità. Il più delle volte, troverò difficile anche passare al setaccio le prime 100 righe o giù di lì. In questi casi, sono più che disposto ad estendere una mano per aiutare a insegnare ad altri programmatori migliori abitudini e programmazione. Se non c'è abbastanza tempo, semplicemente copia / incolla e lavoro i miei progetti nel quadro generale affrontando le loro interfacce scadenti. Successivamente, sono sicuro di offrire molti consigli sulla tecnica di codifica. Quando si tratta di peer review, le critiche costruttive (a prescindere da quanto sgradite) giovano solo a me e lei a lungo termine.

Nel complesso, se hai tempo da perdere, prendilo per insegnare ai tuoi nuovi arrivati ​​come condurre il loro lavoro in modo che tutti siano utili. Prenditi un minuto e insegna loro cosa ha funzionato per te e cosa no. Se non hai tempo, mettiti a nudo con il loro lavoro per ora e assicurati di tornare da loro quando ne hai la possibilità. Fai sapere loro che ci sono modi migliori di fare le cose, specialmente se in futuro lavorerai con loro.


2

Il miglioramento della qualità complessiva è di gran lunga superiore all'utilizzo di una singola persona come "filtro" per un gruppo più ampio. Su quella nota:

  • La programmazione delle coppie funziona come una versione truccata della revisione del codice per capire come sviluppare - è come la differenza tra leggere e fare, raccontare e mostrare. Osservare l'evoluzione del codice e discutere rapidamente delle modifiche è estremamente utile per comprendere non solo il come ma il perché del refactoring e del buon codice. Nella mia esperienza è più veloce dello sviluppo da solo, poiché le idee vengono continuamente lanciate, finendo con un risultato complessivamente di qualità superiore e una migliore comprensione sia del codice che del pensiero dell'altra persona.
  • Gli strumenti di lanugine possono verificare che lo stile di codifica sia seguito. Questo insegna a tutti come formattare il codice e gli errori dovrebbero cadere rapidamente quando gli sviluppatori ricordano lo standard.
    • Fai parte di questo processo di compilazione per assicurarti che sia corretto prima di eseguire il commit.
    • Utilizza i modelli di lingua per assicurarti che CSS, HTML, JavaScript e il codice lato server possano essere controllati separatamente.
  • Gli strumenti di convalida possono verificare che l'output generato sia corretto. Anche questi dovrebbero far parte del processo di compilazione.

2

La migliore pratica sarebbe quella di avere una guida allo stile di codifica e di avere revisioni periodiche, in modo che quando ti avvicini a una scadenza, non stai affrontando questo problema.

La mia raccomandazione è di mostrare la leadership e guidare la revisione periodica del codice. La direzione non viene spinta dall'alto per garantire che si verifichino periodiche revisioni del codice, ma la mia esperienza è che rimarranno impressionati quando un programmatore accelera per pianificare e tenere periodiche revisioni del codice.

Ci sono molti vantaggi per il tuo personale che:

  • imparare uno stile migliore
  • seguire le migliori pratiche
  • imparare a ricercare ciò che stanno facendo

E alcuni vantaggi per te, sarai:

  • più efficiente durante i debug dell'ultimo minuto (che accadrà sempre)
  • riconosciuto come esperto e leader sia dal tuo team che dal tuo management

1
Il problema con le guide di stile di codifica è che tendono a trasformarsi in libri. Molte persone sono disposte a imparare e seguire un insieme di regole abbastanza modesto. Sfortunatamente, a un certo punto queste guide crescono sempre oltre la capacità delle persone di apprendere e ricordare tutte le regole. Hai bisogno di uno strumento che esegua automaticamente i controlli di stile, punto. Le revisioni del codice non dovrebbero essere per l'esecuzione di controlli grammaticali, dovrebbero essere per la ricerca di errori e incomprensioni.
Dunk,

Come programmatore Python e leader della revisione del codice, ho stampato PEP 8 e la guida Python Style di Google almeno una dozzina di volte da passare in giro. Qualunque cosa i programmatori non imparino da loro, si ritroveranno indietro rispetto a quelli che lo fanno. Detto questo, concordo sul fatto che anche un correttore di stile è una buona pratica se è possibile implementarlo.
Aaron Hall,

Non uso Python, quindi non conosco gli strumenti disponibili, ma se ti affidi alle revisioni del codice per applicare le tue regole di stile, stai sprecando centinaia (se non migliaia) di ore all'anno per qualcosa che potrebbe essere fatto per te praticamente senza costi di tempo. Certamente non andrei avanti e implementerei una versione domestica. Spenderei i soldi per comprare una versione commerciale che sarà MODO migliore di qualsiasi cosa possa essere costruita in casa in tempo libero. Anche gli strumenti costosi si ripagheranno più volte.
Dunk

Python, essendo la cornucopia open source che è, ha tutti i tipi di strumenti gratuiti (pylint, pep8, pyflakes), alcuni dei quali abbiamo combinato e migliorato, che da quando abbiamo migliaia di sviluppatori, si ridimensiona davvero bene.
Aaron Hall,

1
: Mi riferivo al tuo frammento "se puoi implementarlo". Se potessi acquistare un correttore di stile, allora è la strada da percorrere. Se puoi far implementare al tuo team qualcosa di utile come questo in un tempo ragionevole, allora deve esserci una società / open source che l'ha già fatto. Quindi sarebbe molto più conveniente acquistarlo semplicemente. Sono sicuro che sarebbe meglio e più aggiornato di una versione "non prodotta" prodotta in casa. Se hai migliaia di sviluppatori, ho ampiamente sottovalutato la quantità di risparmi che uno strumento di controllo automatico di stile / sicurezza fornirebbe.
Dunk

2

Riesco a vedere il motivo nelle risposte "Non aggiustare ciò che funziona" e "Non perdere tempo con ciò che non è importante per il cliente". I PM sono preoccupati per i rischi e questo va bene.

Inoltre capisco che molte persone non prendono bene questo tipo di correzione. Capisco anche questo.

Detto questo, credo che la maggior parte delle scadenze siano artificiali. I sistemi reali vivono sempre più delle scadenze e il cattivo design che fai oggi ti combatterà per sempre. Le persone corrono per consegnare qualcosa in pochi mesi e trascorrono anni dopo aver risolto alcune decisioni sbagliate in un codice che viene eseguito in produzione.

Il debito tecnico è la parola. Un giorno tornerà e qualcuno pagherà per questo.

Quindi, IMO, penso che tu abbia risolto il problema con il design rotto, ed essere professionale (specialmente per i giovani) significa anche che devi sapere come prendere le critiche e come imparare da esso, anche se non è educato. In effetti, la maggior parte della vita non è comunque educata.


0

Qualsiasi risposta diretta sarà estrema. Chiaramente ci sono casi in cui la scadenza è così stretta che devi usare un codice brutto, e ci sono casi in cui il codice è così brutto che vale la pena perdere la scadenza per migliorarlo. Ciò di cui hai bisogno sono i metodi per giudicare in cosa ti trovi e forse i metodi per stabilire scadenze realistiche che consentano il tempo di scrivere codice migliore.

Non salvare la pulizia per dopo. A meno che tu non abbia abitualmente dei periodi con nient'altro da fare se non refactoring, non esiste un "dopo" in cui in qualche modo diventerà una priorità più alta per riordinare il codice di quanto non sia in questo momento. La routine è "rosso, verde, refattore", non "rosso, verde, fare qualcosa di completamente diverso per due settimane, refattore". Realisticamente non cambierai il codice fino alla prossima volta che lo rivedrai per qualche altro motivo, e probabilmente anche tu avrai una scadenza. Le tue reali opzioni sono risolverlo ora o lasciarlo.

Naturalmente un codice ben progettato è meglio di un codice mal progettato, supponendo che tu abbia intenzione di rileggerlo mai più. Se hai intenzione di non leggerlo mai più, non riordinare . Spedisci la prima cosa che supera i test. Ma questo è uno scenario piuttosto raro, per la maggior parte dei programmatori succede quasi mai. Ignorando quel caso, solo tu hai i dettagli del tuo caso reale per esprimere un giudizio su quanto costa riparare e quanto costa (in una futura manutenzione futura) non risolverlo.

Ci sono alcune cose che non sono più difficili da risolvere nel punto in cui il codice richiede manutenzione, rispetto a quelle che devono risolvere ora. Questi in realtà non ti aiutano molto a risolvere ora. I più ovvi sono banali da correggere (errori di spazi bianchi e simili) e quindi è difficile immaginare di avere il tempo di porre questa domanda ma non di risolverli ;-) Per quelli che non sono banali e sono di questo tipo, allora OK , hai del codice che non è l'ideale ma devi essere pragmatico. Funziona e sei in una scadenza. Usalo

Ci sono alcune cose che sono considerevolmente più facili da risolvere ora di quanto lo saranno in seguito quando (a) non sono così fresche nella mente di tutti; (b) sono state scritte altre cose che si basano su di esse o le imitano. Questi sono molto più preziosi da risolvere ora, quindi dai la priorità. Se non hai tempo nelle scadenze per risolverli, allora devi spingere il più forte possibile per scadenze più lunghe, perché stai accumulando debito nella tua base di codice che probabilmente dovrai pagare la prossima volta che visiti il codice.

Il metodo preferito per correggere il codice è attraverso un processo di revisione. Commenta i problemi che hai con esso e invialo al junior per cambiarlo . Potresti dare esempi di ciò che intendi e lasciare che il minore trovi tutti i casi nel codice a cui si applicano, ma non limitarti a terminare il loro codice. Se lo fai, non darai loro alcun mezzo per migliorare.

Dovresti scrivere i problemi più comuni in una guida di stile che dice "non farlo, fallo invece" e spiega perché. In definitiva, la ragione può essere "per rendere il nostro codice esteticamente coerente", ma se non sei disposto a scrivere le tue regole con qualche giustificazione, probabilmente non dovresti neanche applicarle. Lascia solo ogni programmatore libero di scegliere.

Infine, fai attenzione alla tendenza a modificare le cose indefinitamente. I ritorni diminuiscono e devi imparare attraverso l'esperienza dove sono ancora buoni. È assolutamente essenziale che tu formi un'idea realistica di ciò che è abbastanza buono, oppure non puoi avere quella negoziazione in cui ti assicuri che le tue scadenze ti diano il tempo di creare un codice "abbastanza buono". Trascorri il tuo tempo in cose che non sono abbastanza buone.


0

Come molti hanno già detto prima, qualunque cosa lanci in aria tornerà sempre giù. Credo in una forte uniformità su una base di codice. Naturalmente alcune cose non contano molto. Convenzioni di denominazione su variabili locali all'interno di una procedura, ad esempio. Tuttavia, per qualsiasi cosa strutturale, dovrebbe essere riparato immediatamente, prima della fusione finale nel tronco principale. Può essere solo un po 'scadente quando guardi la singola procedura o classe, ma se tutti commettono un codice "leggermente brutto", diventa davvero molto brutto nel suo insieme.

Il brutto codice che funziona spesso funziona bene il 90% delle volte ma cade a pezzi ai bordi. Accertarsi che in genere non sia abbastanza semplice seguendo solo alcune semplici regole. Innanzitutto, dovrebbe essere obbligatorio per ogni programmatore definire e documentare vincoli esatti per ogni procedura o blocco funzionale che producono.

In secondo luogo, per ogni procedura dovrebbe esserci un test contro tali vincoli. Questo dovrebbe essere un semplice test unitario che il programmatore può (e deve) eseguire localmente contro la sua procedura prima di impegnarsi. Ovviamente questo è più facile da gestire con una suite di test adeguata, ma anche senza un test dovrebbe essere scritto e possibilmente commesso in una classe parziale che può essere esclusa dalla build.

In terzo luogo, un set di ambienti di sviluppo standardizzati con strumenti preconfigurati è inestimabile. Un server TS è eccezionale per questo. Ognuno ha gli stessi strumenti (e versioni) esatti, le stesse configurazioni e gli stessi aggiornamenti. Installa uno strumento di refactoring come CodeRush o Resharper, preconfigurato secondo i tuoi standard, e informa i programmatori che rifiuterete qualsiasi commit che abbia ancora degli avvisi. Ora puoi utilizzare il tempo di revisione del codice del tuo team per migliorare effettivamente il tuo set di regole dal loro feedback e il tuo team si correggerà felicemente senza che tu debba costantemente ripulire in seguito. È anche molto più facile per un programmatore prendere le critiche sul codice da uno strumento correttamente configurato piuttosto che da un collega o un capo, in cui gli standard possono sembrare arbitrariamente definiti o non essere compresi correttamente. Se l'IDE ti dice che il tuo codice è scadente, nessuno discuterà con esso e sarà corretto. Scoprirai che la qualità del codice aumenterà notevolmente e il team nel suo insieme impiegherà molto meno tempo a effettuare il refactoring e la pulizia dopo poche settimane. I programmatori si abitueranno anche alle regole e smetteranno di scrivere codice di merda.

Infine, la semplice soluzione qui è semplicemente quella di dare ai programmatori un incentivo a migliorare. I programmatori sono per definizione competitivi. Tutti vogliono avere il codice più bello o più veloce. Un buon modo per motivare tutti, migliorare la produttività e sradicare l'incompetente è quello di calcolare un quadro di valutazione ponderato settimanale per tutti, togliendo punti per impegni respinti e scadenze, ad esempio. Mostra la prima N alla riunione settimanale della squadra, magari paga anche il pranzo a chiunque sia il primo nella media del mese.


0

Suggerisco di utilizzare uno strumento di revisione. Se si dispone di un repository basato su Git è possibile utilizzare lo strumento di revisione di Gerrit . Dopo alcuni commit rifiutati, il team apprenderà gli standard che desideri seguire e i futuri commit non richiederanno alcun lavoro aggiuntivo da parte tua.

Commits attenderà la tua accettazione. Se vedi delle righe che dovrebbero essere riscritte, puoi scrivere commenti e i tuoi compagni di squadra possono riparare il codice da soli in base alle tue esigenze. È davvero un buon modo per imparare gli standard di codifica dei membri del team .

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.