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

38

(Sto parlando del codice HTML / CSS (non dei linguaggi di programmazione) ma penso che anche noi affrontiamo lo stesso problema dei programmatori.)

Sono il progettista di front-end senior di un team e spesso devo rielaborare l'output dei miei juniores in tempi stretti.

Ho due problemi:

  1. Il loro stile di codifica è un po 'confuso.
  2. L'estetica non è buona.

Il loro stile di codifica, trovo, è una borsa mista con nessuna convenzione / standard adeguato. Sono combattuto tra ripulire il codice o semplicemente gestire il loro codice (anche copiare come fanno le cose).

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

Per quelli con molta più esperienza, che è più efficace? Devo salvare la pulizia per dopo? Oppure ripulisci mentre apporto le modifiche?

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

    
posta catandmouse 17.03.2014 - 03:36
fonte

14 risposte

79

Credo che tu stia esaminando il problema nel modo sbagliato - ti manca una grande opportunità di insegnare ai ragazzi come scrivere un codice migliore.

Se riscrivi abitualmente il loro codice, potresti dare ai tuoi junior l'impressione che non apprezzi il loro lavoro, il che abbasserà il morale e non li aiuterà a codificare meglio la prossima volta.

Un approccio migliore, credo, è quello di aggiungere al processo di sviluppo del tuo team un compito di revisione del codice. Non deve riguardare ogni pezzo di codice impegnato, e non lo fa (direi che non dovrebbe) deve essere condotto solo da te - ogni volta che un membro della tua squadra finisce un compito abbastanza grande che dovrebbe abbinalo a uno (o più) dei suoi compagni di squadra, spiegagli il codice e ricevi opinioni costruttive e critiche sul suo design, stile di codifica, possibili bug e problemi di sicurezza, ecc.

Quando il compagno di squadra di revisione del codice sei tu imparerà dalla tua esperienza molto di più quando semplicemente riscrivi il loro codice (hanno la possibilità di sentire il motivo il codice dovrebbe essere cambiato), e potrebbe prendere meno offesa.

Offrire loro la possibilità di condurre anche le revisioni del codice migliorerà ulteriormente le loro capacità - vedere come gli altri scrivono codice e perché - e aumenterà la loro autostima.

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

    
risposta data 17.03.2014 - 09:16
fonte
29

L'ho già detto e lo dirò di nuovo "il codice di lavoro è più prezioso di un bel codice".

Se modifichi il codice, è molto probabile che cambi il suo comportamento, se questo è il codice testato, hai appena invalidato tutti gli sforzi di test e dovrai ripetere i test.

Incoraggia in ogni modo i tuoi ragazzi a scrivere codice comprensibile e pulito, ma se stai per riscrivere tutto ciò che scrivi, stai sprecando più volte i tuoi datori di lavoro. Devono pagare per i tuoi juniores, quindi pagare per farti fare quello che hanno già pagato ai tuoi juniores e poi pagarti ancora una volta per fare il lavoro per cui ti hanno effettivamente assunto.

    
risposta data 17.03.2014 - 05:35
fonte
16
  • La risposta breve è: no. Quando i tempi sono difficili, a volte devi solo abbassare la testa e prendere la pallottola estetica. ;)

  • Una risposta più pragmatica è il time-box. Budget un'ora per scorrere e ripulire un aspetto specifico del codice. Quindi controllalo e fai del vero lavoro. Ma sii onesto con te stesso sul fatto di tenerlo vincolato.

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

  • Fai attenzione alle guerre di stile. Soprattutto in una situazione di scadenza serrata, se hai intenzione di annullare alcune preferenze stilistiche che l'altro programmatore rifarebbe, allora è meglio aspettare fino a quando non hai il tempo di capire davvero come vuoi indirizzarti questioni stilistiche in modo cooperativo. (Il che significa dare e avere.)

Ma c'è un valore di giudizio nella risposta. Direi "moderatamente" importante. Un codice pulito può davvero rendere il lavoro più veloce, e la qualità del codice è, dopo tutto, parte del deliverable. Non penso di poter toccare il codice (nemmeno il mio) senza spendere un po 'di tempo per la pulizia. Ma assicurati che l'agitazione con stile, formato e guerre di stile non diventi più importante di ottenere il codice in produzione.

    
risposta data 17.03.2014 - 04:01
fonte
9

Durante la correzione del codice e la scadenza, utilizzo normalmente due regole:

The code is awful but it's possible to find an issue in reasonable time and fix it

Risolve un problema e lascia il resto intatto .

The code is so messy that it's really hard to find an issue there. Fixing something causes breaks immediately something else. It would be probably faster to write that code from scratch than fixing it.

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

Il caso borderline è:

The code is messy and really bad. It's still possible to fix a bug in reasonable time, but the code structure will make it really hard to maintain. Any new feature is very likely to introduce new bugs or cause significant performance decrease.

In questo caso, il codice deve essere corretto, ma solo quando le nuove funzionalità devono essere implementate, attive durante il tempo di inattività, mai in tempo di correzione dei bug in vista della scadenza!

    
risposta data 17.03.2014 - 10:12
fonte
6

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

In senso stretto, in questo magico mondo ideale che nessuno di noi abita, tutto il codice promosso o implementato dovrebbe essere perfetto. Non è così a volte devi essere pragmatico.

Tuttavia, se si dispone di un processo di revisione del codice, è necessario evidenziarlo prima di eseguire il test. Se sei costantemente contro le scadenze, i problemi sono le stime per la consegna, il che significa che una componente chiave di qualsiasi processo di sviluppo, ad esempio la revisione del codice, viene strangolata?

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

    
risposta data 17.03.2014 - 09:24
fonte
4

Dipende dalla cultura generale. Se le scadenze ravvicinate sono sporadiche, accetta che dovrai effettuare la pulizia in un secondo momento. Se sono costanti, allora stai costruendo 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 principi darwiniani.

    
risposta data 17.03.2014 - 06:42
fonte
3

Per contribuire a ridurre il problema in futuro, sviluppa un documento di standard e pratiche di codifica interno che tutti i dipendenti devono seguire.

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

    
risposta data 17.03.2014 - 04:01
fonte
2

Sono abbastanza inesperto con la programmazione. Come studente, tuttavia, mi impegno spesso a rivedere le pari e collaborare a progetti. Se c'è tempo sufficiente per terminare un progetto, procederò e ripulire il codice di un membro del team per chiarezza e leggibilità. Più spesso, trovo difficile persino setacciare le prime 100 righe o giù di lì. In questi casi, sono più che disposto a estendere una mano per aiutare a insegnare a un altro programmatore le migliori abitudini e la codifica. Se non c'è abbastanza tempo, faccio semplicemente copia / incolla e lavoro i miei progetti nell'immagine grande che si occupa delle loro povere interfacce. In seguito, sono sicuro di offrire molti consigli sulla tecnica di codifica. Quando si tratta di revisione tra pari, le critiche costruttive (indipendentemente da quanto sgradite) avvantaggiano a lungo termine sia lui che lei. Se collaborerò con le stesse persone in futuro, posso stare tranquillo sapendo che avevano alcune linee guida informative premute nella loro mente, e spero solo che il prossimo giro funzioni molto più agevolmente.

Nel complesso, se hai tempo da perdere, prendilo per insegnare ai tuoi nuovi arrivati come condurre il loro lavoro in modo che tutti possano trarre beneficio. Prenditi un minuto e insegna loro cosa ha funzionato per te e cosa no. Se non hai tempo da perdere, lasciati al 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 lavorerai con loro in futuro.

    
risposta data 17.03.2014 - 06:33
fonte
2

Migliorare la qualità generale è di gran lunga superiore all'utilizzo di una singola persona come "filtro" per un gruppo più grande. In tale nota:

  • La programmazione accoppiata funziona come una versione truccata della revisione del codice per capire come svilupparsi: è come la differenza tra leggere e fare, raccontare e mostrare. Guardare il codice evolversi e discutere rapidamente delle modifiche è estremamente utile per comprendere non solo il modo, ma il perché del refactoring e del buon codice. Nella mia esperienza è più veloce che si sviluppa da solo, dal momento che le idee vengono continuamente sballottate, finendo con un risultato complessivo di qualità superiore e una migliore comprensione sia del codice che del pensiero dell'altra persona.
  • Gli strumenti di sfilacciamento possono verificare che lo stile di codifica venga seguito. Questo insegna a tutti come formattare il codice, e gli errori dovrebbero scomparire rapidamente una volta che gli sviluppatori ricorderanno lo standard.
    • Esegui questa parte del processo di creazione per assicurarti che sia corretto prima di eseguire il commit.
    • Utilizza i modelli di lingua per assicurarti che i tuoi CSS, HTML, JavaScript e codice lato server possano essere controllati separatamente.
  • Gli strumenti di convalida possono controllare che l'output generato sia sano. Anche questi dovrebbero essere parte del processo di compilazione.
risposta data 17.03.2014 - 14:04
fonte
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 ti trovi di fronte a questo problema.

La mia raccomandazione è che tu mostri leadership e guidi la normale revisione del codice. Il management non viene spinto dall'alto per assicurarsi che si verifichino periodicamente le revisioni del codice, ma la mia esperienza è che rimarranno impressionati quando un programmatore farà il passo per pianificare e mantenere revisioni regolari del codice.

Ci sono molti vantaggi per la tua gente, che lo faranno:

  • impara lo stile migliore
  • segui le migliori pratiche
  • impara a ricercare cosa stanno facendo

E alcuni vantaggi per te stesso, sarai:

  • più efficiente durante i debug dell'ultimo minuto (che avverrà sempre)
  • riconosciuto sia come esperto sia come leader sia dal team che dal management
risposta data 17.03.2014 - 21:10
fonte
2

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

Inoltre, capisco che la maggior parte delle persone non prenda bene questo tipo di soluzione. 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 batterà per sempre. Le persone corrono per consegnare qualcosa in pochi mesi e trascorrono anni dopo aver corretto alcune decisioni sbagliate in un codice che viene eseguito in produzione.

Il debito tecnologico è la parola. Tornerà un giorno e qualcuno pagherà per questo.

Quindi IMO, penso che tu abbia ragione nel correggere il design rotto, e essere professionale (specialmente per i ragazzi) 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 è educata comunque.

    
risposta data 18.03.2014 - 03:54
fonte
0

Ogni risposta diretta sarà estrema. Chiaramente ci sono casi in cui la scadenza è talmente stretta da dover usare un brutto codice, e ci sono casi in cui il codice è così brutto che vale la pena perdere la scadenza per migliorarlo. Quello di cui hai bisogno sono i metodi per giudicare in che modo ti trovi, e forse i metodi per impostare scadenze realistiche che ti permettono di scrivere un codice migliore.

Non salvare la pulizia per dopo. A meno che non si abbia abitualmente periodi con nulla da fare se non refactoring, non c'è "più tardi" in cui in qualche modo diventerà la priorità più alta per riordinare il codice di quanto lo sia in questo momento. La routine è "rosso, verde, refactoring", non "rosso, verde, fare qualcosa di completamente diverso per due settimane, refactoring". Realisticamente non cambierai il codice fino alla prossima volta che lo stai rivisitando per qualche altra ragione, e probabilmente anche tu avrai una scadenza. Le tue vere opzioni sono di ripararlo ora o lasciarlo.

Ovviamente il codice well-styled è meglio del codice in stile cattivo, supponendo che tu abbia intenzione di leggerlo di nuovo. Se hai intenzione di non leggerlo più, allora non riordinarlo . Spedisci la prima cosa che supera i test. Ma questo è uno scenario piuttosto raro, per la maggior parte dei programmatori accade approssimativamente mai. Ignorando tale caso, solo tu hai i dettagli del tuo caso reale per esprimere un giudizio su quanto costa fissare rispetto a quanto costa (in una maggiore manutenzione futura) a non risolverlo.

Ci sono alcune cose che non sono più difficili da risolvere nel punto in cui il codice richiede manutenzione, piuttosto che risolverle ora. Questi in realtà non ti danno molto da sistemare ora. Le più ovvie sono banali da correggere (errori di spazi bianchi e simili) e quindi è difficile immaginare che tu abbia il tempo di fare questa domanda ma non di risolverle ;-) Per quelle che non sono banali e sono di questo tipo allora OK , hai un codice che non è l'ideale ma devi essere pragmatico. Funziona e sei in scadenza. Usalo.

Ci sono alcune cose che sono considerevolmente più facili da sistemare ora di quanto lo saranno in seguito quando (a) non sono così freschi nella mente di tutti; (b) sono state scritte altre cose che si basano su di loro o le imitano. Questi sono molto più preziosi da sistemare ora, quindi assegnali le priorità. Se non hai tempo nelle tue scadenze per sistemarle, devi spingere il più possibile per scadenze più lunghe, perché stai accumulando debiti nel tuo codice base 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 rimandalo al junior per cambiare . Potresti fornire esempi di ciò che intendi e lasciare il junior per trovare tutti i casi nel codice a cui si applicano, ma non solo finire il loro codice per loro. Se lo fai, non dai 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é. Alla fine si può permettere che la ragione sia, "per rendere il nostro codice esteticamente coerente", ma se non sei pronto a scrivere le tue regole con qualche giustificazione allora probabilmente non dovrebbero farle rispettare o. Lascia ogni programmatore libero di scegliere.

Infine, fai attenzione alla tendenza a modificare le cose indefinitamente. I rendimenti diminuiscono, e devi imparare attraverso l'esperienza in cui sono ancora buoni. È assolutamente essenziale formarsi un'idea realistica di ciò che è abbastanza buono, altrimenti non si può avere quella negoziazione in cui ci si assicura che le scadenze ti consentano di creare un codice "abbastanza buono". Passa il tuo tempo a cose che non sono abbastanza buone.

    
risposta data 17.03.2014 - 22:22
fonte
0

Come molti hanno già detto prima, qualunque cosa tu lanci in aria tornerà sempre giù. Credo in una strong uniformità su una base di codice. Ovviamente alcune cose non contano molto. Ad esempio, le convenzioni di denominazione sulle variabili locali all'interno di una procedura. Tuttavia, per qualcosa di strutturale, dovrebbe essere risolto subito, prima della fusione finale nel tronco principale. Potrebbe sembrare un po 'scadente quando osservi la singola procedura o classe, ma se tutti eseguono il codice "un po' brutto", diventa davvero molto brutto nel suo complesso.

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

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

In terzo luogo, un set di ambienti di sviluppo standardizzati con strumenti preconfigurati ha un valore inestimabile. Un server TS è superbo per questo. Tutti hanno gli stessi strumenti (e versioni), le stesse configurazioni e gli stessi aggiornamenti. Installa uno strumento di refactoring come CodeRush o Resharper, preconfigurato secondo i tuoi standard, e dai ai programmatori che rifiuterai qualsiasi commit che abbia ancora avvertimenti. Ora puoi utilizzare il tempo di revisione del codice del tuo team per migliorare effettivamente il tuo set di regole dal feedback, e il tuo team si corregge felicemente senza dover continuamente ripulire. È anche molto più facile per un programmatore prendere le critiche del codice da uno strumento correttamente configurato che da un collega o capo, in cui gli standard possono sembrare arbitrariamente definiti o non correttamente capiti. Se l'IDE ti dice che il tuo codice è scadente, nessuno ne discuterà e verrà corretto. Scoprirai che la qualità del codice aumenterà drasticamente, e il team nel suo insieme spenderà MOLTO meno tempo per refactoring e pulizia dopo alcune settimane. I programmatori si abitueranno anche alle regole e smetteranno di scrivere codice crap.

Infine, la semplice soluzione qui è semplicemente quella di dare ai programmatori un incentivo per 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 è calcolare un tabellone settimanale ponderato per tutti, togliendo punti per i commit rifiutati e scadenze spezzate, ad esempio. Mostra la prima N alla riunione settimanale della squadra, magari anche il pranzo a chi è il primo delle medie del mese.

    
risposta data 19.03.2014 - 00:23
fonte
0

Suggerisco di utilizzare uno strumento di revisione. Se disponi di un repository basato su Git, puoi utilizzare lo strumento di revisione 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.

I commit attenderanno la tua accettazione. Se vedi delle righe che dovrebbero essere riscritte, puoi scrivere commenti e i tuoi compagni di squadra possono risolvere il codice da soli in base alle tue esigenze. È davvero un buon modo per imparare i standard di codifica del team

.

    
risposta data 17.03.2014 - 10:48
fonte

Leggi altre domande sui tag