Come si torna a un codice quando non si ricorda cosa stavi facendo? [duplicare]

Suppongo che tu non stia utilizzando un tracker di problemi per il tuo progetto. Altrimenti sarebbe banale tracciare i passi precedenti.

Ricerca delle ultime modifiche

Trovare il file su cui stavi lavorando prima di procrastinare non dovrebbe essere un grosso problema. Se stai usando uno strumento di gestione del codice sorgente (SCM) come Git, leggere la cronologia dovrebbe aiutare. Se non si utilizza alcun SCM o sistema di controllo versione (VCS), è ancora possibile ordinare i file per data di modifica ( ecco come farlo in una shell UNIX ).

Ricordando le tue intenzioni

La parte difficile è ricordare perché stai facendo qualcosa. Se il codice è così difficile da leggere che il suo scopo non è chiaro, eseguo l'analisi del codice statico. Lo faccio nello stesso modo in cui lo farei per capire il codice che è stato scritto da qualcun altro. Mentre cerco di seguire il flusso del programma, disegno diagrammi UML (principalmente diagrammi di classi e attività, in casi veramente brutti anche diagrammi di sequenza). Questo non aiuta solo a comprendere il codice, ma serve anche come documentazione futura.

Evitare il problema in futuro

Prima di tutto, se il tuo problema principale è che non riesci a ricordare i tuoi intenti precedenti perché il codice è così difficile da comprendere, questo è il momento per il refactoring. Ti farà risparmiare un sacco di problemi in futuro. Se, tuttavia, il problema è che hai più strutture di codice non terminate e non riesci a ricordare cosa finire prima, potresti provare uno o più dei seguenti:

SCM : se non stai utilizzando SCM / VCS, inizia a farlo. In caso di monitoraggio dei passaggi precedenti, SCM ti aiuta se mantieni una cronologia pulita (ricorda il principio: "commit early, commit often" ). Inoltre, ti impedisce di cancellare irrevocabilmente i file (ad es. Con UNIX ' rm ).

Problema tracker : se tutto ciò non ti aiuta ancora a evitare i problemi, inizia a utilizzare un tracker dei problemi. Esistono innumerevoli strumenti gratuiti e leggeri per aiutarti a tenere traccia dei tuoi cambiamenti.

Test delle unità : un altro metodo che può aiutarti a trovare rapidamente il posto dove continuare il tuo lavoro consiste nel creare test unitari. Esistono framework per tutti i linguaggi ampiamente utilizzati (ad esempio, Java, C, Objective-C, ...) e alcuni linguaggi hanno persino un framework di questo tipo nelle loro librerie standard (ad es., Python). Se pensi che i test unitari possano aiutarti, dai uno sguardo allo sviluppo guidato dai test (TDD). Per molti sviluppatori sembra davvero strano non iniziare subito a programmare, ma scrivere test per qualcosa che non c'è. Tuttavia, può portare a una prospettiva completamente nuova dello sviluppo del software.

Se tutti questi suggerimenti sembrano essere eccessivi, potresti semplicemente scrivere TODO commenti nel tuo codice. Questa non è la soluzione più pulita e sicura, ma la più semplice e veloce.

1. Esegui i test. Se ho fallito i test, probabilmente è quello su cui stavo lavorando.
2. Diff copia di lavoro contro il controllo di revisione. Vedere tutte le modifiche che ho apportato di recente ma non commesso di solito mi ricorda quello che stavo facendo.
3. Leggi cronologia del commit. Inizia a cercare nella cronologia del controllo della versione cosa è successo di recente. Questo di solito mi riconduce alla road map e alla prossima attività sulla lista.

In tali situazioni, trovo utile dare un'occhiata ai casi d'uso e provare ad associarli al codice sorgente. In altre parole, fai finta di essere uno dei tuoi utenti più importanti e pensa a cosa farebbero usando il tuo sistema. Pensa al compito più importante che avrebbero cercato di portare a termine con il tuo software e quali misure avrebbero intrapreso per portare a termine il loro lavoro. Quindi, pensa a come sarebbe implementato e quali parti del codice sorgente eseguiranno ciascuna funzione. Quindi inizierai a familiarizzare nuovamente con il codice base.

Prenditi il tuo tempo. Non cercare di sapere tutto in una volta. Una volta che hai imparato come funziona una singola funzione, ti aiuterà a imparare il prossimo e così via.

Buona fortuna.

Una volta soffrivo dello stesso problema. Non perché il mio codice fosse così disordinato, ma semplicemente perché a volte uno è interrotto più a lungo di quanto inizialmente previsto e quindi semplicemente dimentica le cose che non si pensava di dimenticare inizialmente. Un elenco di cose da fare può essere d'aiuto, ma di solito non è abbastanza dettagliato.

Poi ho sviluppato l'abitudine di lasciare alcuni piccoli appunti all'interno del codice, vicino al luogo in cui avevo intenzione di continuare a lavorare. Questo non è controllato nel VCS, è solo per me. Forse due / tre linee è sufficiente per catturare i più recenti quando si esce dal lavoro.

Quando torni più tardi, premi semplicemente "compile" e il compilatore mostrerà il posto (non compilabile) nel codice, dove hai lasciato le note. E questo è il punto di partenza.

Potrebbe non funzionare in tutti i casi a cui si possa pensare, ma per me lo fa.

Tutto quello che faccio è tenere un file TODO / di un taccuino e prima di andare avanti per una lunga pausa (> ora), scrivo ciò che resta da fare. La mia mente quindi estrapola ciò che stavo facendo prima. Lo faccio sempre e non delude mai.

Bene, oltre a qualsiasi malattia ti abbia interrotto, sembra che tu abbia fondamentalmente due problemi.

1. A lack of version control and bug tracking.  Get one of the many free 
   VCS/bug trackers/project managment.  TFS from Microsoft, git and Jira or 
   or even FogBugz from Fog Creek.  There's a bunch out there, pick one or 
   just try a bunch.
2. Having lost track of what you were doing, you're now in something like 
   analysis paralysis -- and the solution is the same.  Do something.  It 
   doesn't matter what you were working on, it will come back to you if it's 
   important, and you can work on something else important until then.

Questo è il punto in cui lo strumento di gestione del progetto di tua scelta può risplendere - hai bug che devono essere corretti e funzionalità da aggiungere. Puoi dare la priorità a loro e registrare su quale stai attualmente lavorando. Inizia a farlo. Buone possibilità che mentre inserisci tutti i tuoi bug noti e le funzionalità desiderate, ricorderai ciò che stavi facendo.

Per prima cosa, impara la lezione.

Da ora in poi, scrivi codice facile da capire:

• Documentalo. Strumenti come Doxygen sono molto utili. In realtà, Doxygen è utile anche con codice non documentato con la sua capacità di disegnare albero delle chiamate, albero del chiamante e albero delle dipendenze.

• Non cercare di sembrare intelligente quando scrivi codice. Non utilizzare funzioni avanzate solo per mostrare che ne sai di loro.

Ricorda che la documentazione e il codice semplice vengono letti non solo da altri manutentori, ma principalmente dal tuo io futuro.

Ciò che è stato già suggerito è probabilmente utile, ma in generale utilizzerei un sistema di tracciamento dei problemi o di gestione delle attività (come Jira ) per pianificare e gestire il tuo lavoro. Ci sono anche strumenti aggiuntivi (come Mylyn per Eclipse) che integrano l'IDE al sistema di gestione delle attività.