Rifacendo costantemente il mio codice ... una pessima pratica

Question

Ho una strana domanda qui.

Sono l'unico programmatore qui che si sente costantemente come se dovessi riscrivere/refactoring i miei codici?

A volte lo faccio solo perché mi che la velocità potrebbe essere migliorata, o semplicemente perché credo il codice potrebbe essere facilmente importato in un progetto più tardi.

Ehi, a volte solo perché sembra cleaner per i miei occhi.

Sono malato? Sono anch'io perfezionista? Sono l'unico ad avere questo problema?

Answer 1

A volte mi rifattore per rendere più facile la lettura o l'esecuzione più veloce o più facile da estendere. Tuttavia nel mondo reale con scadenze e lavorando per te stesso, puoi permetterti di farlo solo se hai una ragione per farlo!

Answer 2

personalmente preferirei lavorare su codice come sopra/da qualcuno piuttosto che codice da qualcuno che lo lascia dopo il primo tentativo. assicurati di non entrare in gold plating.

Answer 3

Dai uno sguardo allo TDD. La premessa fondamentale è:

1. scrivere la prova di mancanza
2. scrivere il codice per far passare il test di
3. aggressivamente refactoring

Come principio generale penso refactoring aggressivo è una buona idea - perché avere più codice di quello che ti serve davvero. La difficoltà arriva in due parti, in primo luogo, perché refactoring senza uno scopo e secondo, come fai a sapere che non hai funzionalmente modificato il codice refactored se non disponi di una suite di test in base alla quale puoi testare la versione refactored? TDD è una risposta a entrambe queste cose.

Vorrei incoraggiarvi a prendere l'abitudine di refactoring, ma vorrei anche incoraggiare una pratica come TDD in modo da non infrangere il codice mentre lo fai.

HTH

Answer 4

si sono probabilmente solo vivendo comprensione iterativa del problema. Fai una pugnalata per questo e poi quando hai finito, hai acquisito qualche nuova intuizione. Questa nuova intuizione si applica, solo per sapere che hai di nuovo una nuova visione, quindi buttare via parte del codice e riscriverlo.

Non si dovrebbe modificare il codice per essere più veloce se si si pensa che sia. È necessario misurare tramite profilatura o esecuzioni di clock. E dovresti sapere a quale livello hai bisogno che il codice sia migliorato. Alcuni codici necessitano di un miglioramento della velocità molto ridotto per essere adeguati.

Answer 5

No, non sei solo. Direi che questo è esattamente ciò che rende un buon programmatore - non essere mai soddisfatto di quello che stai facendo, aspirare a migliorare te stesso invece di ripetere le stesse cose più e più volte.

Answer 6

Tutto dipende, se lo può permettere refactoring, significato, non c'è bisogno di altri compiti più importanti nella vostra coda di allora refactoring in "facile da leggere" il codice è sempre una buona cosa;)

E anche dipende dalla situazione Se fai parte di un team più grande, il refactoring potrebbe significare un apprendimento più veloce del tuo codice da parte di altri sviluppatori.

Durante il refactoring a volte si scopre problemi/casi che non vengono visti da QA o da testo, ma è anche possibile dare alla luce altri problemi che potrebbero non essere visti ... qualcosa da tenere a mente.

direi continuare refactoring un pezzo di codice se:

• non si dispone di compiti più importanti nella vostra coda di
• si fissa un problema relativo prestazioni
• altri compagni di squadra pensano il tuo codice fa schifo (codice disordinato) e ha bisogno di essere organizzato meglio! in questo caso si è l'unico sviluppatore, quindi è necessario per giudicare la vostra roba
• hai scritto 40 righe di codice per qualcosa che si sa potrebbe essere scritto in 2 linee, ma aveva bisogno di farlo uscire velocemente

Codice disordinato = dichiarare le variabili dappertutto, non utilizzare il principio orientato agli oggetti, non incapsulare frammenti di codice e riscrivere lo stesso codice più volte, in loop ovunque! brutto collega, senza commenti, ecc ... ecc ...

Chiunque ha più casi?

Answer 7

Ho trovato utile questa regola pratica: "Non dovrei dedicare più tempo al refactoring che all'implementazione della funzionalità richiesta dall'utente."

Potrei avere molte altre idee su come il codice potrebbe essere migliorato, ma trovo utile migliorarlo un po ', ogni volta che ci lavoro su, piuttosto che cercare di raggiungere "la perfezione" tutto in una volta con tutto codice.

È come il motto del boy scout: lascia meglio di quando l'hai trovato.

Answer 8

Nelle fasi iniziali di un progetto è necessario un refactoring costante. Probabilmente non riuscirai a trovare la soluzione migliore e le modifiche ai requisiti possono rendere la soluzione perfetta in un secondo momento.

Tuttavia, una volta passati attraverso un paio di cicli di test di integrazione e UAT, inizierei a essere cauto riguardo al refactoring. Dopo tutto, hai investito tempo e impegno per verificare il codice che hai; il refactoring sprecherà questo sforzo di test e richiederà la ripetizione dell'intero ciclo di test.

Answer 9

Stai chiedendo di riscrivere entrambi i reflex e e temo che le risposte siano diverse. Se si esegue costantemente il refactoring, non è necessario essenzialmente riscrivere. Il refactoring, fatto bene, mette il tuo codice in stato ideale per le sue esigenze attuali, senza la riscrittura. Questa è una bella cosa.

vi elenco una serie di ragioni per questo:

1. perché la velocità potrebbe essere migliorata;
2. perché il codice potrebbe essere facilmente importato in un progetto successivo;
3. perché sembra più pulito.

Di questi, vorrei dire scartare n. 1 e n. 2 e attaccare solo con n. Ecco perché. Il refactoring non dovrebbe cambiare il comportamento, quindi il codice refactored dovrebbe funzionare in modo identico all'originale (ci sono alcune avvertenze sui casi limite a questo, ma non considerare mai il refactoring come un approccio di ottimizzazione). Le regole di ottimizzazione sono:

1. Do not;
2. Vedere la regola n. 1;
3. Quando è assolutamente necessario, il profilo , quindi ottimizzare solo i bit lenti.

E l'ottimizzazione è in genere più una questione di riscrittura che di refactoring. Il refactoring può metterti in una posizione migliore per l'ottimizzazione (mi viene in mente un metodo di estrazione), ma in genere non renderà il tuo codice più performante da solo. Quindi non refactoring "per rendere più veloce il tuo codice"; refactoring nel corso di rendere il tuo codice più veloce, perché stai ottimizzando, non per un capriccio.

Riguardo alla riutilizzabilità - YAGNI. Quando il "progetto successivo" arriva - se mai - e sai che c'è qualcosa da prendere in prestito da un progetto precedente, se solo fosse un po 'diverso - è il momento di ridisegnare, per soddisfare le nuove esigenze. Prima che il progetto esista, hai già rifattorizzato il codice del primo progetto per soddisfare idealmente i suoi bisogni (a progetto singolo); solo quando arriva il nuovo bisogno è un altro disegno più desiderabile. Non anticipare. Aspetta la necessità di guidare il tuo design.

Bottom line: refactor per rendere il codice migliore per le sue esigenze immediate. Rendilo leggibile, rendilo manutenibile. Utilizzare il refactoring anche a supporto di altre operazioni, ma non in previsione di esse. E non sentirti male per il refactoring tutto il tempo. Se qualcosa sembra sbagliato nel tuo codice, è bene ripararlo.

Answer 10

Faccio lo stesso. A lungo termine, spero che mi consenta di scrivere subito codice più pulito, più veloce, più riutilizzabile, ecc. E credo, che stia già succedendo. Penso sempre di più a una nuova linea di codice, prima che lo hackerò. Quindi spero di fare meno refactoring in futuro. Ma credo che ci arriverò solo attraverso il refactoring.