LOC è probabilmente una delle metriche più abusate e, di conseguenza, è probabilmente una delle misure più inutili della qualità del codice e una misurazione ancora più inutile dello sforzo di programmazione.
Sì, è una dichiarazione audace da parte mia, e no, non posso indicarti degli studi che dimostrino il mio punto. Tuttavia, posso affermare con molta esperienza che quando inizi a preoccuparti di quanto codice hai scritto, probabilmente ti stai preoccupando dei problemi sbagliati.
Per prima cosa è necessario chiedersi che cosa si sta tentando di misurare o dimostrare, e se questa prova è semplicemente fuori interesse, o per supportare un miglioramento della qualità più ampio e dove è necessario utilizzare queste informazioni per ottenere il buy-in dal tuo team / gestione per fare qualcosa al riguardo.
Una delle cose che tendo ad usare LOC per è un po 'un controllo di sanità mentale. Se mi ritrovo a scrivere molto codice, divento più interessato a LOC per metodo, a LOC per classe, piuttosto che a LOC su tutto. Queste misure potrebbero essere indicatori che hai ulteriormente rifatto a fare se ti senti un po 'OCD su quanto dovrebbe essere ben fattorizzato il tuo codice. Le classi molto grandi potrebbero devono essere refactored in alcune classi più piccole e lunghi metodi multilinea potrebbero essere suddiviso in diversi metodi, in altre classi, o può anche indicare alcune ripetizioni che potrebbero essere rimosse. Notate che ho usato la parola "potrebbe" diverse volte lì.
La realtà è che LOC fornisce solo un possibile indicatore e nessuna garanzia reale che il tuo codice possa dover essere modificato. La vera domanda da porsi è se il codice si comporta come richiesto e come previsto. In tal caso, la tua prossima domanda è se sarai in grado o meno di mantenere il codice facilmente e se avresti il tempo ora o in futuro di apportare modifiche al codice funzionante per ridurre i costi di manutenzione in futuro.
Spesso, un sacco di codice significa che ne avrai di più da conservare in seguito, ma a volte anche codice ben calcolato può estendersi a centinaia di righe di codice, e sì, a volte puoi trovarti a scrivere centinaia di righe di codice in un giorno. L'esperienza tuttavia mi dice che se sto sostenendo un output di centinaia di righe di nuovo codice ogni giorno, che spesso c'è il rischio che gran parte del codice sia stato tagliato e incollato in modo inappropriato da qualche altra parte, e che di per sé possa indicare problemi con duplicazione e manutenzione, ma ancora una volta non è una garanzia, quindi tendo a fare affidamento su ciò che la mia esperienza e il mio istinto mi dicono in base a come sono stati completati i compiti da svolgere.
Il modo migliore per evitare il dilemma posto nella tua domanda IMHO è dimenticare LOC e refactoring TUTTO il tempo. Scrivi prima il test del codice, implementa in errore, il refactoring passa, quindi vedi cosa può essere refactored lì e quindi per migliorare il codice. Lascerai l'incarico sapendo che hai già ricontrollato il tuo lavoro e non sarai così preoccupato di pensare a te stesso in futuro. Realisticamente parlando, se utilizzi un approccio test-first come ho descritto, qualsiasi misura di LOC / giorno sul tuo codice completato significherebbe davvero che hai scritto 3-5 volte l'importo misurato, con tale sforzo nascosto con successo dal tuo refactoring in corso sforzi.