Quanto spesso dovrei compilare?

How can I get out of this irrational compile/debug habit

Pratica. Ciò che mi ha aiutato è consolidare le mie capacità di progettazione del programma. Avere bisogno di "assicurarti che funzioni" è un segno che ti manca la fiducia in ciò che hai fatto. Prendi fiducia attraverso la pratica, ovviamente, ma anche usando le cose che sai funzioneranno. Prendendo modelli noti (non necessariamente modelli di progettazione, ma contano) e adattandoli alla situazione attuale. Dal momento che li hai già fatto molte volte in passato, li conosci abbastanza bene da farli bene ed essere sicuro di averli fatti bene.

how often should I actually be compiling

Personalmente, non consiglio la compilazione finché non sei pronto per eseguire i test. Ci sono troppi ambienti di codifica che hanno una compilazione sucky a causa della lingua che stai usando (ti sto guardando C ++), della piattaforma su cui stai lavorando, o della dimensione / complessità del codice base. È bello poter lavorare senza quel passaggio e concentrarsi sulla compilazione parziale / controllo degli errori che gli IDE più moderni forniscono mentre lavori.

Ma è solo una raccomandazione. Fai ciò che è più produttivo per te.

and debugging my application

Quando i test falliscono, o è stato segnalato un bug che ha eluso i test (e non è possibile individuare il bug senza entrare nel debugger). Questo dovrebbe essere molto raro quando si sviluppa un nuovo codice ed è un brutto segno se necessario quando si aggiunge al codice esistente.

Ancora una volta, tendo ad evitare il debugger in questi giorni per ragioni simili che evito il compilatore. Inoltre, una volta che la maggior parte del codice è nota, i pattern che individuano i bug diventano più rapidi poiché ti è familiare dove le cose possono andare storte.

Anche questa è solo una raccomandazione. È bello essere in grado di individuare i bug con il codice eyeballing, ma l'obiettivo finale è quello di produrre software di qualità. Se il debugger ti dà quell'obiettivo più velocemente e in modo più affidabile, vai avanti e fai il debug di frequente.

In breve, ci sono 3 cose che ho fatto per migliorare la produttività quando sono nella tua situazione:

• Buona registrazione invece di debug
• Test unitario

• Build giornaliero

  1. Raccomando vivamente di accedere al debug usando IDE . Con un buon file di registro, avrai un accesso molto più rapido a "cosa è successo" e al flusso dell'errore, senza ricompilare. Inoltre, la registrazione ti aiuterà anche a risolvere i problemi dell'applicazione quando viene utilizzata dai client, mentre il debug non lo fa.

  2. Molte persone qui sembrano consigliare il test dell'unità, ma sappi che ci vorrà del tempo per imparare e applicare. I cattivi test unitari non ti aiuteranno. Potresti provare a iniziare in piccolo e ad aggiungerli alla funzione più importante e soggetta a errori della tua applicazione.

  3. Una build quotidiana e alcuni test di integrazione per un flusso di lavoro aziendale importante sono un'altra cosa che mi salva la vita così tante volte. La configurazione di una build-and-deploy automatica non è difficile, ma aiuterà te ei tuoi colleghi a fare in modo che nessuno interrompa nulla per errore prima del test di accettazione.

Ti consiglio anche di dare un'occhiata a il test di Joel . È molto utile per coloro che cercano di migliorare:)

UPDATE: Ulteriori informazioni sulla registrazione. Basta inserire una dichiarazione println qua e là nel codice potrebbe funzionare, ma si vorrà una libreria di logging completa se si è intenzionati a risolvere i problemi in futuro. Ogni linguaggio / framework di programmazione ha ora una solida struttura per la registrazione, quindi puoi contare su questo.

Il test unitario è la risposta. Un buon framework ti consentirà di eseguire solo i test a cui sei interessato al momento. E i test unitari sono piccoli per definizione, quindi verranno compilati e eseguiti velocemente.

Per prima cosa, dovresti usare un ide molto buono con strumenti per aiutarti a "pre-verificare" la tua logica di codice. Qualcosa come l'eclissi o delphi o nusfera, a seconda della lingua.

In secondo luogo, devi dividere il tuo lavoro sui codici di lavoro. Al termine di un lavoro, compili solo i file che sono stati aggiornati e li collegano al resto.

Compila bene e spesso. Lo faccio normalmente dopo che ogni blocco di nuove funzionalità è stato completato. Non è insolito che ciò avvenga decine di volte al giorno.

Tuttavia, l'IDE dovrebbe davvero ricompilare solo quei file che ne hanno bisogno. Non si dice quale lingua si sta usando, ma se si aggiornano i file di intestazione, qualsiasi file di origine che lo include dovrà essere ricompilato. Una ricompilazione completa ogni volta potrebbe essere un sintomo di codice mal organizzato.

Se stai usando un linguaggio compilato strongmente tipizzato, dovresti davvero compilare molto spesso, dal momento che fornisce un primo controllo di integrità che non hai scritto alcun codice non valido. Quanto più a lungo si prende tra creare l'errore e rilevarlo, tanto meno fresco sarà nella vostra mente. Se il tuo progetto richiede molto tempo per essere compilato, esegui invece una compilazione incrementale. (Se non puoi farlo, usa un IDE che lo supporta.)

E se le tue compilazioni incrementali impiegano troppo tempo, in cosa stai programmando? Su Delphi posso compilare completamente la nostra (enorme, ~ 4M linee) app client in circa 2 minuti su un disco rigido e una VM, o ~ 15 secondi su un SSD e nessuna VM. Le compilazioni incrementali sono ancora più veloci. Se la produttività è importante, potrebbe essere una questione di "lo strumento giusto per il lavoro giusto". (Il che non vuol dire che dovresti abbandonare l'intera base di codice esistente e riscrivere l'intera faccenda in Delphi solo perché si compila più velocemente.Questo sarebbe sciocco, ma dovresti tenere a mente che non tutto si costruisce altrettanto lentamente.)

Per quanto riguarda l'esecuzione di test e debug, dovresti farlo abbastanza spesso. Non necessariamente tutte le volte che si esegue il test, ma ogni volta che si completa una funzione o una funzione secondaria, è necessario sottoporla a una prova rapida o due subito, anche se verrà successivamente testata in altri modi o da altre persone. Ricorda, più a lungo passerai tra la scrittura del codice e il rilevamento dell'errore, più difficile sarà per te risolvere il problema.

In genere ho le cose da configurare per compilare ogni volta che salvi un file. Ovviamente per farlo funzionare è necessario uno strumento di compilazione che ricompili solo i file che devono essere compilati. Generalmente uso GNU Make per questo. In realtà ho il mio editor per compilare il file e individuare gli errori di sintassi con la modalità flymake di Emacs, quindi probabilmente esegue una compilazione ogni pochi secondi.

Il trucco qui è che non stai ricostruendo l'intero progetto ogni volta che compili, stai solo costruendo il componente che è cambiato.

Costruirò tutto da zero una volta ogni poche ore, in genere se passo a un nuovo ramo o qualcosa di simile.

Lavori su Dotnet? Se sì, allora può essere utile per te.

1. In vari progetti aggiunti, ci saranno alcuni / molti riferimenti, assicurati di fare tutti i riferimenti per avere la proprietà Copia locale come FALSE
2. Se stai sviluppando materiale ASP.NET, fai in modo che il codice di tutte le pagine Aspx sia nascosto come file di codice per evitare che Build e persino il loro salvataggio possano eseguire il lavoro + l'applicazione non deve essere riavviata più e più volte. (Ma assicurati, prima di inviare l'implementazione, vale a dire prima della finale li fai nuovamente CodeBehind, dato che il codice precompilato funziona meglio in qualsiasi momento)
3. Vai a un progetto specifico e crea solo quello (fai clic con il tasto destro del mouse > Crea progetto) anziché costruire o ricostruire la soluzione completa. Questo farà risparmiare un sacco di tempo.

Spero che questo aiuti!