(assumendo il codice di produzione)
Tendo ad andare un po 'oltre. Ho scritto di rendere i programmi "a prova di idiota", ma non sempre lo qualifico: scrivo un sacco di codice con cui altre persone non vedranno o lavoreranno (almeno, questa è l'attesa quando è scritta). iosono l'idiota da cui sto cercando di difendermi in quel caso. È una buona cosa quando il tuo programma rileva problemi per te e il problema è stato semplificato così tanto che è abbastanza ovvio che c'è un errore e la sua origine. La verità è che i dettagli di implementazione sono evidenti quando si scrive un programma (a meno che non lo si stia implementando prematuramente), ma dovrebbero essere astratti e resistenti agli errori per i client (anche quando esiste la località del modulo). Il motivo è che i programmi diventano molto complessi. A volte è possibile separare i problemi, ma non sempre. Se mantieni i tuoi componenti molto rigidi, semplici, ben incapsulati e a prova di idiota, tendono a ridimensionarsi bene e la maggior parte dei difetti vengono rilevati prima della spedizione. È più facile da riutilizzare e hai più fiducia e un tempo più facile riutilizzare i programmi. quei programmi complessi che scrivi diventano più complessi (anche a te) dopo un po 'di tempo lontano dal programma. Quando lo leggi in 6 mesi, può essere necessario un tempo assurdo per capire ed eseguire il debug rispetto alla versione a prova di idiota. Se un componente introduce un cambiamento di rottura, altrimenti potrebbe non essere rilevato per molto tempo. I programmi sono complessi; non puoi sfuggire a quella realtà, ma puoi renderla una prova idiota, il che renderà la tua vita molto più semplice quando qualcosa va storto o quando deve essere riutilizzato o modificato. Pertanto, l'approccio a prova di idiota significa che il tuo software può essere compreso, riutilizzato o mantenuto dai tuoi junior o da persone più nuove nel team (non solo qualcuno buono / esperto come te). La sostituzione è una preoccupazione separata: se le persone adorano lavorare con i tuoi programmi, stai facendo un buon lavoro - non non preoccuparti per la sostituzione. Certo, potrei inventare scenari in cui programmi incomprensibili potrebbero salvare il tuo lavoro, ma scrivere un buon programma che gli altri possono usare e mantenere è chiaramente il male minore (guarda le risposte degli altri). Se mi sorprendo a scrivere qualcosa che non è una prova idiota, provo a risolverlo.
A parte lo scenario, in cui hai bisogno di documentazione per te stesso per continuare un progetto dopo 6 mesi di pausa, qui sembra esserci un chiaro conflitto di interessi tra lo sviluppatore e la società di software.
Davvero non hai idea di cosa stavi pensando qualche volta quando rivisiti le implementazioni inattive. Quando sei veramente esperto, il problema è più semplice perché puoi fare più affidamento su metodologie o approcci consolidati che usi. Ciò, tuttavia, presuppone anche che queste metodologie siano invarianti. Anche se la documentazione può essere lenta, devi comunque essere difensivo nelle tue implementazioni (ad es. Sai meglio che passare NULL in questo scenario - prova quella condizione).
Quindi, come programmatore, dovresti davvero scrivere un'ottima documentazione e un codice facilmente leggibile per tutti; o dovresti scrivere codice e documentazione in modo tale che funzioni e tu stesso possa capirlo, ma un'altra persona potrebbe avere difficoltà a capirlo?
Raccomando l'approccio a prova di idiota, che è ancora più chiaro e più resistente agli errori rispetto all'approccio del fattore bus. Scrivi i tuoi programmi e la documentazione in modo tale che possano essere facilmente compresi da qualcuno esterno al progetto: è un bene anche per te. In questo modo aumenterai il tuo valore per la tua azienda e il tuo team, non vorranno sostituirti.