Ho avuto una discussione con un collega ieri sulla filosofia del design. L'altro programmatore è più esperto di me, e ammetto pienamente che probabilmente è molto più bravo a automatizzare correttamente i suoi test, che sto solo cercando di rompere con le abitudini sbagliate. Tuttavia, sembra che alcune delle nostre controversie siano questioni filosofiche in cui non sono disposto a cedere semplicemente alla sua maggiore esperienza.
Generalmente è un programmatore regista, che segue tutti gli approcci formali. Ha interfacce per quasi tutte le classi e ha eseguito test automatici per tutto fino a getter e setter su oggetti POJO di base. Vede il refactoring come una parolaccia che è un segnale che le cose non sono state scritte / progettate correttamente dall'inizio, è inevitabile e fatto come necessario ma tutto dovrebbe essere fatto per evitare di doverlo fare e dovresti sentirti male quando devi .
Sento di essere un programmatore più flessibile / abilitante. Ritengo che le interfacce debbano essere utilizzate come necessario, ma non lanciate fino a quando non sono necessarie (KISS), e che è abbastanza facile estrarre un'interfaccia da un oggetto esistente mediante refactoring se si decide che un'interfaccia / polimorfismo ha più senso in seguito. Sentivo anche che, mentre ammetto che devo essere più bravo a fare i test, al momento, il livello dei test automatici che ha suggerito sembravano troppo rigidi poiché ci sarebbe voluto così tanto tempo per implementare e, cosa più importante, rendere il refactoring un incubo dato che non avrei essere liberi di modificare il comportamento di qualsiasi metodo non privato. Man mano che le mie esigenze crescono e cambiano, mi ritrovo a dover eseguire pesantemente il refactoring e quel livello di test sembra che possa uccidere la mia flessibilità. Il suo punto di vista è che non dovrei essere refactoring, quindi non importa se i test lo rendono più difficile da fare.
In definitiva tutte le altre discussioni filosofiche sembravano ridursi alla parola "refactoring". Adoro il refactoring, penso che dovrebbe essere usato liberamente ogni volta che senti che qualcosa non è così pulito e bello come dovrebbe essere, e che il corso naturale per far crescere un programma o aggiungere nuovi requisiti richiederà il refactoring per abilitare meglio il codice riutilizzare, spostare la logica verso nuove classi / pacchetti man mano che diventa più complessa, e sì fissando gli inevitabili errori di progettazione che avverranno da un approccio flessibile allo sviluppo agile (e non è sempre male se il tuo codice è scritto per consentire modifiche!). Non è d'accordo con tutto ciò.
Mi chiedo quali sono i pensieri degli altri sul refactoring. Quanto comune dovrebbe essere? Scrivere codice con una filosofia di "Lo sto facendo in modo semplice ora, posso rifattenerlo in seguito se la logica più complicata si rivela necessaria" intrinsecamente imperfetta / pericolosa? L'accettabilità del refactoring dipende dall'approccio e dallo stile del programma? Generalmente sono sulla prototipazione rapida o "ripulisci questo brutto, ma lavorando, prototipo di alcuni non-ingegneri hanno scritto", mentre sembra che possa effettivamente fare una programmazione formale con requisiti ufficiali che non cambiano; Non ho mai avuto un lavoro del genere nemmeno io!