C'è un modo per evitare di spaghetti code negli anni?[chiuso]

https://stackoverflow.com/questions/369683

21-08-2019
|

Domanda

Ho avuto diversi lavori di programmazione.Ognuno con 20-50 sviluppatori, progetto in corso per 3-5 anni.

Ogni volta è la stessa.Alcuni programmatori sono luminose, alcune sono nella media.Ognuno ha il CS di laurea, tutti di leggere i modelli di progettazione.Le intenzioni sono buone, le persone stanno cercando di scrivere del buon codice, ma ancora dopo un paio di anni il codice diventa spaghetti.Cambiamenti nel modulo a si rompono modulo B.Ci sono sempre queste parti di codice che nessuno può capire, tranne per la persona che lo ha scritto.La modifica di infrastrutture è impossibile e la compatibilità impediscono buone caratteristiche per entrare.Metà del tempo che si desidera solo per riscrivere tutto da zero.

E persone più esperte di me, trattare questo come normale.È?Non si tratta di essere?Cosa posso fare per evitare questo o devo accettare come un dato di fatto della vita?

Edit:Ragazzi, io sono impressionato con la quantità e la qualità delle risposte qui.Questo sito e la sua comunità rock!

Soluzione

diligenza Ruthless combinazione con analisi unità costante è l'unico modo per impedire spaghetti code. Anche allora è solo una soluzione cerotto. Non appena si smette di pagare l'attenzione viene fuori la pasta.

Molto spesso trovo che spaghetti code è introdotto perché qualcuno è semplicemente essere pigri quel giorno. Sanno che c'è un modo migliore per farlo e semplicemente non hanno il tempo. Quando si vede che questo accada c'è solo una cosa da fare.

Li chiamano su di esso e chiedere loro di cambiare

Trovo che sottolineando il modo migliore nel corso di una revisione del codice di solito è sufficiente per convincere la gente che va. Se controllano dentro e mi sento fortemente, mi refactoring io stesso.

Ho occasionalmente venire fuori come un po 'eccentrica? Sono sicuro che faccio. Francamente anche se non mi dispiace. Io non sono un coglione su di esso e avvicina a questo nel miglior modo possibile sociali. Tuttavia lasciando codice cattivo ottenere registrati praticamente assicura che sto andando ad avere per eseguire il debug ad un certo punto in futuro. Preferisco prendere un po 'di contraerea ora e ottenere il codice a destra dentro.

Ritengo inoltre che una cultura di unit testing aiuta anche a prevenire spaghetti code. E 'molto più difficile da unità di spaghetti code test che ben scomposto codice. Nel corso del tempo questo costringe le persone a mantenere il loro codice di un po 'di factoring.

Altri suggerimenti

Credo che la chiave per evitare il codice marciume si trova in basso verso l'alto di progettazione e realizzazione di metodologie sonori (credo che così forte che ho chiamato la mia attività - Pensate basso verso l'alto -! Dopo). Gli strumenti di scelta qui sono:

Programmazione contrattualmente
disegno a strati
Focus su disaccoppiamento
costruire Sempre con il riutilizzo in mente, alla ricerca di soluzioni generiche
Mantenere framework leggero, semplice e mirato

Come suggerito da altri intervistati, è necessario individuare i problemi in anticipo. Con gli sviluppatori verde, questo significa che il mentoring (pair programming è grande qui) e recensioni (revisioni del codice e design). Con gli sviluppatori più alti, questo significa vigilanza.

La maggior parte di tutti, non abbiate paura di refactoring. Se refactoring si spaventa, si sta già affondato. Se refactoring è vista come "cattivo", allora c'è qualcosa che non va con il tuo business.

Quando si corregge qualcosa, risolvere il problema in modo corretto. Uso il termine "Fux" per descrivere una correzione che è stato fatto nel modo sbagliato:. È solo "Fux" la vostra base di codice

Saluti,

Dan

20 a 50 sviluppatori è probabilmente il problema. Che è piuttosto alto e avrebbe bisogno di un sacco di gestione e di risorse per tenere tutto sotto controllo.

Vorrei pensare di dividere il progetto in segmenti più piccoli riutilizzabili. Estratto alcuni strati di distanza dal sistema centrale.

Crea "firewall" tra le diverse aree del codice. A tale scopo, la definizione delle aree o strati di codice differenti, e definente una singola API (in Java, ciò avviene di norma con un'interfaccia) che ogni strato risponde. Non ci dovrebbero essere bare-bones Interfacce o classi che l'API utilizza, ma che "sapere" nulla circa la struttura interna di questi strati. Per esempio, l'interfaccia grafica non dovrebbe sapere o preoccuparsi di come si memorizzano i dati, e il database non deve sapere o di assistenza come i dati vengono presentati per l'utente finale.

Queste API non devono essere gettato nella pietra - si dovrebbe essere in grado di aggiungere le cose, se necessario, fino a quando si assicurarsi che non inquinano l'firewall

Penso che il punto principale è che quando si dice

si desidera solo per riscrivere tutto da zero

Solo abbracciarla.
Utilizzare un numero di unità di test, in quanto possibile, quindi consentire il refactoring di essere una pratica comune.
Automatizzato e unit test di garantire che le modifiche apportate non introdurre regressioni;dedicando una certa percentuale del vostro tempo per il refactoring di codice vecchio (e questo significa, meno nuove funzionalità!) garantire la base di codice esistente non invecchiare, o almeno non così in fretta.

Le revisioni del codice, standard di codifica e le politiche aziendali.

Quello che segue è applicabile al nostro negozio - dal momento che non so che tipo di negozio che hai, la tua situazione potrebbe essere diversa. Mentre si muove a Team Foundation Server, una gran parte della nostra attenzione si è concentrata sul mantenimento della qualità del codice - o per lo meno aiutare a mantenere la qualità in ogni modo possibile. Alcuni esempi di ciò che stiamo aggiungendo:

Code Review Workflow - fa rispettare la revisione del codice come parte del processo. Contiene una politica che impedisce il check-in si verifichi se il codice non è stato rivisto.
TeamReview - rende il codice del cliente meno doloroso, fornendo un completo "all'interno dell'IDE" esperienza
Politiche di check-in (in generale) - Molti extra fresche disponibili per il controllo del flusso di codice. Cose come fare in modo che i metodi pubblici e protetti sono documentati prima del check-in per fare in modo che nessun lavoro può essere controllato in senza un corrispondente elemento di lavoro.

Come ho detto, se si utilizza una piattaforma diversa, forse le attrezzature disponibili e che cosa si può fare è diverso. Ma non escludo utensili ad aiutare in ogni modo possibile. Se è possibile utilizzare per migliorare, controllare e verificare il flusso di lavoro e gli oggetti che si muovono al suo interno, si dovrebbe essere almeno la pena di considerare.

Ricordate, le eventuali modifiche in corso stanno andando a coinvolgere pushback. Il modo in cui abbiamo aiutato ad alleviare questo è quello di costruire le politiche nella formazione per la transizione dal nostro vecchio / sistema di tracciamento dei difetti di controllo della versione.

Sembra che molti non stanno seguendo alcuni principi fondamentali della encapsualtion e buon design.

Mantenere le cose isolate e unreliant su altre parti è essenziale per evitare il problema che si descrive. Potrebbe essere necessario un po 'di designer di livello superiore o architetto. Questo è uno scenario tipico in cui le persone hanno giustificato alcuni processi draconiane e gestione del cambiamento. (Io non sostengo che)

È necessario evitare le dipendenze e le interrelazioni e definire e utilizzare solo interfacce pubbliche. Questo naturalmente è una semplificazione eccessiva, ma probabilmente imparare molto da alcune metriche sul codice - complessità delle classi, metodi pubblici, diagrammi UML costruite dal reverse engineering del codice, ecc

Credo che l'accoppiamento lasco si può ottenere con l'uso conclamata di iniezione di dipendenza è una caratteristica tecnica che può aiutare molto. Quando viene divisa, i pezzi della domanda si è meno probabilità di ottenere gli spaghetti derivanti dal riutilizzo "interessante".

Si può essere a capo di eccessiva frammentazione, invece, ma questo è un altro problema e meno di problema strutturale globale.

Non permettere che il codice da impegnare fino a quando almeno due paia di occhi hanno visto.

refactoring

Strive mantenere il design più pulito possibile. Questo non è facile, ma vale la pena lo sforzo.

Non credo che sia normale. E 'davvero difficile per combattere questa cosa quando si era lì per un paio di anni.

L'unico modo per evitarlo è quello di cambiare l'atteggiamento:

“L'atteggiamento che gli sviluppatori agili hanno verso la progettazione del software è lo stesso atteggiamento che i chirurghi hanno verso la procedura sterile. Procedura sterile è ciò che rende la chirurgia possibile . Senza di essa, il rischio di infezione sarebbe troppo alto per tollerare. Gli sviluppatori agili pensano allo stesso modo dei loro disegni. Il rischio di lasciare anche il più piccolo frammento di marciume iniziare è troppo alta per tollerare.” Martin C. Robert “Agile principi, modelli e pratiche in C #”

Consiglio vivamente di guardare in questo libro per consigli. nomi It All "progettazione odori", le ragioni della loro esistenza e le conseguenze della loro partenza. Possa questo vi aiuterà a convincere la gestione che la situazione attuale non è appropriato.

In bocca al lupo!

Il problema più grande nel settore del software è che la qualità del codice di programmazione è vista come una questione soggettiva. Senza qualche metrica ben definito, solo di essere pulito e ordinato, e seguendo le convenzioni non è sufficiente a garantire che la qualità è accettabile.

Ci sono tentativi di cambiare questo , ma è improbabile per ottenere interessi o l'accettazione sufficienti soprattutto perché la cultura di lunga data di programmatori è nel cercare molto difficile stare lontano da tutto ciò che assomiglia di ingegneria. La filosofia "pura arte" della programmazione significa che i 20-50 sviluppatori stanno tutti andando a flagellare il codice nel proprio modo unico, in modo che non importa quanto bene i singoli programmatori, la somma totale di sforzo del gruppo sta andando sempre essere "una grande palla di fango".

Per evitare questo, sia ottenere tutti i codificatori sulla stessa 'pagina', far parte di codice normalizzato del vostro convegno, o inseguire i lavori sono stati i team di sviluppo sono più piccole (1-3 persone) e sei grande kahuna. Un giorno le grandi squadre possono trovare un modo per costruire una migliore roba, ma fino ad allora anche i migliori di loro sono estremamente fortunati se si può solo avvicinarsi a 6 su 10. Costruiamo un software di bassa qualità perché è quello che abbiamo creato la nostra industria a fare ...

Paul.

È necessario seguire da vicino le pratiche di sviluppo software. Ci devono essere le revisioni del codice e unit test che constastantly si assicurano che gli aggiornamenti sono che interessano altre cose nel sistema. 20 - 50 sviluppatori è molto, ma può essere fatto. Implementazione di buoni processi è l'unica cosa che vi farà risparmiare in questo ambiente. standard di codifica forzate sono anche la chiave.

monitoraggio difetti e le prestazioni delle varie parti del sistema vi permetterà di identificare i problemi. Poiché i sistemi vengono cambiati mal progettati o scritti funzioni o moduli hanno un più alto tasso di difetti. Quando viene individuato un modulo di "problema" una decisione può essere fatto per riscrivere il modulo (non l'applicazione).

refactoring continuo. sono di refactoring, come si va, soprattutto a livello di progettazione. Quando si vede il codice rotto o di progettazione, essere pronti a risolvere il problema. Questo è spesso un caso di aggiustare qualcosa che non è rotto, di per sé. Tranne che è ... è solo che non manifesta è brokenness ... ancora.

Shore e Warden di The Art of Agile Development è un grande libro, con una sezione su "Applicazione di XP a un progetto esistente" (capitolo 4). Progetti peggiorare nel tempo a meno che non si combatte duramente: superare tale debito tecnica è duro e renderà sempre più difficile per spedire release accettabili. L'unica soluzione è quella di ridurre la velocità con cui si esprime nuove funzioni, e trascorrere il tempo risparmiato migliorare la copertura di test e refactoring.

Di solito, i progetti non hanno copertura di test molto, e non hanno la possibilità di esecuzione di uno script 10 minuti automatizzato che costruirà ed esercitare il vostro codice di abbastanza bene. Invece, la maggior parte del codice è strutturato in modo che è difficile da verificare. L'opzione migliore è quindi di aggiungere semplice copertura di test in cui è possibile, durante l'avvio di refactoring, al fine di rendere il codice astratte in modo che sia più facile da testare.

Anche se la squadra avrà bisogno di trascorrere del tempo migliorare il codice per renderlo pulito e verificabile probabilmente non sarà in grado di fermare la consegna per il tempo che ci vuole "finire" la pulizia. Quindi, si deve fare un passo alla volta, mentre anche l'aggiunta di nuove funzionalità. Va bene, scegliere i settori peggiori prima, e non si aspettano vantaggio evidente subito. Tenere a esso, perché alla fine ci si arriva. Non ascoltare le voci che dicono tutti i grandi progetti sono cattivi.

In breve, trascorrere un po 'di tempo ogni settimana mettere in ordine, e assicurarsi che il codice è migliore la settimana prossima di quanto lo sia questa settimana.

Ulteriori revisioni del codice e, forse, il codice di proprietà.

Se solo hack un codice a caso, allora non si cura tanto quanto per il codice è "proprietario". Se è la vostra responsabilità di mantenere un modulo del progetto, si vuole brillare.

E revisioni del codice è un momento in cui si mostra il tuo codice.

Avviare la creazione di test di unità, questo vi aiuterà a disaccoppiare il codice e di evitare errori di follow-up su correzioni di bug. Si avete una buona copertura che sarà più facile per voi per rimuovere il codice non utilizzato come bene.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow