Quanto è importante ridurre il numero di righe nel codice?

85

Sono uno sviluppatore di software che lavora su J2SE (core java).
Spesso durante le nostre revisioni del codice ci viene chiesto di ridurre il numero di righe nel nostro codice.

Non si tratta di rimuovere il codice ridondante, si tratta di seguire uno stile che si concentra sul fare le stesse cose con meno righe nel codice, mentre io credo di avere chiarezza nel codice anche se questo significa aumentare il numero di righe.

Quale pensi sia il modo giusto di fare le cose?
Se LOC (linee di codice) è un numero piccolo, come influenza il codice? Se LOC è un numero maggiore, in che modo influisce sul codice?

esempio dal sito web: "javaranch" -

public static void happyBirthday(int age)
{  
    if ((age == 16) || (age == 21) || ((age > 21) && (((age % 10) == 0) || ((age % 25) == 0))))        
    {
        System.out.println("Super special party, this year!");
    }
    else
    {
        System.out.println("One year older. Again.");
    }
}

VS

public static void happyBirthday(int age)
{

    boolean sweet_sixteen = (age == 16);
    boolean majority = (age == 21);
    boolean adult = (age > 21);
    boolean decade = (age % 10) == 0;
    boolean quarter = (age % 25) == 0;

    if (sweet_sixteen || majority || (adult && (decade || quarter)))
    {
        System.out.println("Super special party, this year!");
    }
    else
    {
        System.out.println("One year older. Again.");
    }
}
    
posta Ankit 22.10.2014 - 22:46
fonte

20 risposte

74

Il problema delle misurazioni, non importa quanto siano ben intenzionate, è l'atto stesso di misurare l'elemento che lo rende importante, e il corollario, l'atto di non misurare un oggetto lo rende poco importante. È assolutamente essenziale misurare ciò che è importante e non misurare ciò che non è importante.

Misurare SLOC (che è effettivamente ciò che stanno facendo le tue recensioni), rende SLOC importante .... Lo SLOC è importante? - assolutamente no, mai stato (Fuori concorsi di programmazione offuscati ), non sarà mai in un'organizzazione commerciale.

Porsi una semplice domanda: come "Ridurre lo SLOC di questa routine" rende migliore il codice di qualcuno. Quello che probabilmente sta accadendo in questo caso è che SLOC viene usato come un modo ingenuo per misurare la complessità. Quello che devi evitare a tutti i costi è contare i fagioli facili da contare - misure oggettive come SLOC, invece di contare gli importanti ma difficili da contare - ad es. Leggibilità, complessità ecc.

    
risposta data 13.04.2017 - 14:38
fonte
83

Sono d'accordo con i revisori del codice, ma con un asterisco. Ogni affermazione che scrivi nel tuo codice è una responsabilità tecnica - è un potenziale punto di errore. Se scrivi un metodo con 10 affermazioni e il tuo collega ne scrive uno che raggiunge la stessa funzionalità con 5 affermazioni, è probabile che il suo sia 'migliore' come misurato dalla probabilità di problemi (ci sono il doppio di posti che il tuo codice può essere sbagliato, eccessivamente complesso, o problematico).

Ecco l'asterisco, però. Non si tratta del numero effettivo di linee di codice nell'idea perché è possibile ridurre il numero di linee con qualcosa del tipo:

void someMethod() {   
 someobject.doSomething(someSingleton.getInstance().with().a().lot().of().law().of().demeter().violations()).and().if().that().werent().enough().theres().more();
}

Questa è una riga di codice, ma è un luogo in cui una quantità incredibile di cose può andare storta. Quindi direi di concentrarsi sul fare di più con il minor numero di affermazioni - scrivere tanto codice quanto è necessario per fare le cose e non di più. Almeno, penso che sia ciò a cui stanno guidando i revisori del codice.

Personalmente, penso che ci sia un equilibrio da colpire. Come ho detto, ogni affermazione che scrivi è una responsabilità, ma se estrarre una variabile locale con un nome descrittivo rende il tuo metodo molto più chiaro e più leggibile, allora c'è un caso da fare anche per quello. Penso che tu possa facilmente entrare in situazioni in cui le persone stanno cavillando su differenze estetiche relativamente minori, ma nel complesso, penso che i tuoi revisori abbiano l'idea giusta: favorire la riduzione al minimo del numero di cose che possono andare storte.

    
risposta data 05.04.2013 - 22:02
fonte
32

Prendere il consiglio dei revisori letteralmente non servirà a nulla, perché l'ovvio risultato diretto è la promozione di one-liner concisi (nonostante il limite di lunghezza della linea). Credo che la lezione da imparare qui, però, sia quella di fare in modo che il tuo codice faccia meno cose .

In altre parole, questo è un invito alla semplicità. È piuttosto popolare affermare che il codice è una responsabilità, non una risorsa , quindi ridurre la quantità preservando la funzionalità è uno sforzo nobile. Questo può essere ottenuto con un approccio diretto, più concreto, che affronta il problema direttamente e preferisce soluzioni concise.

Come diceva Ken Thompson: uno dei miei giorni più produttivi è stato buttare via 1000 righe di codice .

    
risposta data 05.04.2013 - 22:03
fonte
21

Tendo ad essere d'accordo con la tua posizione di "avere chiarezza nel codice anche se questo significa aumentare il numero di linee."

Ho visto troppi one-liner che sono abbastanza concisi, ma non è immediatamente evidente ciò che stanno facendo. La leggibilità è il re poiché altri sviluppatori dovranno mantenere il tuo codice.

Direi che una cosa migliore da mirare sono i metodi brevi. Non corto per poche righe di codice, ma breve perché fanno una cosa sola.

    
risposta data 05.02.2013 - 07:36
fonte
12

Attualmente lavoro come senior application developer e project business analyst per una grande azienda e mai il conto di linea del mio sviluppo è stato un centro di interesse. Tuttavia, credo che quanto più condensato possa essere un codice, tanto meglio, MA non a costo di essere in grado di analizzarlo rapidamente e correggerlo (o aggiungerlo a). Per me, quando sei responsabile dell'applicazione business critical che DEVE avere un vasto livello di scalabilità e capace di alterazioni al volo in un ambiente in continuo cambiamento, il codice conciso e di facile lettura è uno degli elementi più importanti nello sviluppo . A credito della risposta di Erik Dietrich , questo:

void someMethod() {   
someobject.doSomething(someSingleton.getInstance().with().a().lot().of().law().of().demeter().violations()).and().if().that().werent().enough().theres().more();
}

sarebbe del tutto inaccettabile per me, tuttavia, ho trovato che modifica tutto il codice esistente delle aziende da:

if (boolean == true){
value.prop = option1;
}
else{
value.prop = option2;
}

a:

value.prop =  boolean ? option1 : option2;

è stata un'ottima scelta di condensazione del codice che non sacrifica la leggibilità.

Per quanto riguarda l'effetto del codice? Non ho mai notato un aumento o una riduzione delle prestazioni da, diciamo, 100 righe di codice. Il semplice fatto è che è più il processo che utilizzi per arrivare al prodotto finale che il numero di linee necessarie per arrivare lì. Ho visto alcuni processi scritti molto condensati, per quanto inefficienti, che funzionano in modo diverso rispetto ai codici più lunghi con un migliore flusso di codice.

    
risposta data 12.04.2017 - 09:31
fonte
9

IMO, è una cattiva idea misurare l'efficacia del codice con un conteggio LOC banale. C'è molto di più in ciò che rende il codice correttamente progettato ed efficace.

Nella mia esperienza, codice efficace:

  • non infrange nessuno dei principi SOLID
  • è leggibile e autoesplicativo
  • supera la prova di semplicità di Albert Einstein: "Tutto dovrebbe essere reso il più semplice possibile, ma non più semplice".
risposta data 06.01.2016 - 10:42
fonte
6

Qui ci sono molte risposte che affrontano i pro ei contro tecnici di tenere giù LOC e se si tratta di una metrica del software di qualità significativa. Non è di questa domanda. Si tratta di come affrontare la gestione che insiste su un'ingenua aderenza dogmatica a una particolare regola empirica della codifica.

Purtroppo, è abbastanza comune per le persone aggrapparsi a cose che sono buoni consigli quando usate nel contesto appropriato e applicate pragmaticamente, portarle fuori da quel contesto e applicarle dogmaticamente senza riuscire ad apprezzare i problemi che il consiglio esiste per mitigare in il primo posto.

L'intento del consiglio di mantenere LOC giù è di evitare la creazione di metodi che cercano di fare troppo in una volta, e di scoraggiare la creazione di "divinità", che sanno troppo su aspetti di un design che non sono sono la loro diretta responsabilità e da cui dipendono tutte le altre classi del sistema. Un altro vantaggio del codice più breve è che è più leggibile, anche se come hai sottolineato, puoi esagerare fino al punto in cui la leggibilità inizia effettivamente a soffrire.

Ci sono ovvi vantaggi per i bassi conteggi di LOC (piccoli metodi si adattano alla tua testa più facilmente di quelli grandi, meno cose nel codice significano meno cose da sbagliare, ecc.), ma è anche soggetto alla legge dei rendimenti decrescenti . Il refactoring di un metodo a 150 linee in un numero di 20 metodi di linea è una vittoria molto più grande rispetto al refactoring di un metodo a 10 linee in un metodo a 7 linee.

Quando tale refactoring viene a scapito di qualche altro aspetto del buon design del software (come la leggibilità), allora hai raggiunto un punto in cui puoi giustificare di non farlo. Rimuovere le variabili che danno un contesto a ciò che il codice significa e sostituirle con letterali che non lo sono è una cosa molto brutta da fare. Il buon codice non ha quasi letterali in esso. Tuttavia, queste variabili (e le costanti nominate) sono linee di codice che non contribuiscono direttamente al programma e quindi se LOC viene adorato come una sorta di dio, allora tali linee di chiarimento sono in grave pericolo di essere potate per una rapida vittoria e qualche elogio fuorviato da parte della direzione.

Credo che tu sia abbastanza intelligente per rendertene conto, in effetti questo è praticamente l'essenza della tua domanda originale. Il problema non è la vostra comprensione di quando la riduzione del codice è buona e quando non lo è, il problema è il dogmatismo nell'applicare ciò che normalmente è una pratica ragionevole indiscriminatamente.

Consiglierei di dedicare del tempo a chattare con la tua direzione, spiegando la tua posizione e il motivo per cui ritieni che ciò che ti viene chiesto di fare danneggi il codice piuttosto che aiutarlo. Cerca di evitare di essere conflittuale, ma cerca di rimanere razionale e calmo durante questa discussione. È importante che il management capisca che la programmazione è un'attività pragmatica e che i consigli sulle best practice sono utili solo se applicati in modo pragmatico. La migliore pratica è scritta in un libro, non scolpita nella pietra, e quando è in conflitto (codice corto o codice leggibile), spetta al programmatore applicare il proprio giudizio su quale migliore pratica seguire. Speriamo che siano persone ragionevoli che apprezzano l'input come questo.

Devi anche essere un po 'coraggioso, perché se sei sotto pressione per ridurre LOC dove pensi che sia inutile o inappropriato, allora è naturale che tu faccia il resto comunque per una vita tranquilla. Devi resistere a fare questo, e devi "possedere" quella decisione. In una situazione in cui la gestione è ragionevole, non dovresti rispettare esattamente le loro linee guida, ma dovresti essere in grado di giustificare le circostanze in cui non lo sei.

Tristemente, le persone possono essere irrazionali, specialmente quando si tratta di persone che non rispettano l'ordine gerarchico che mettono in discussione le loro decisioni e le regole che ti hanno imposto. Possono scegliere di non essere ragionevoli. Devi essere preparato anche per questo. Se è possibile dimostrare casi in cui la migliore pratica di LOC entra in conflitto diretto con altre migliori pratiche e perché questo danneggia il prodotto, e se lo si può fare in porzioni della base di codice per cui hanno avuto poco o nessun coinvolgimento personale (quindi non sembra un attacco personale al loro lavoro o al loro lavoro supervisionato), quindi questo potrebbe aiutare a rafforzare la tua argomentazione. Ancora una volta, devi essere pronto a giustificarti in modo calmo, razionale ed essere in grado di "possedere" gli argomenti che stai facendo.

Se la tua gestione è composta da persone ragionevoli, allora devono comprendere che ciò che dici è un merito se puoi fornire prove a sostegno delle tue richieste.

    
risposta data 07.04.2013 - 09:29
fonte
2

Penso che dovresti davvero cercare di avere funzioni con un piccolo numero di SLOC.

If LOC (lines of code) is a small number, how does it effect the code and if LOC is a larger number, how does it effect the code ?

Idealmente, dovrebbe essere più facile capire a colpo d'occhio 8 linee di codice di quanto dovrebbe essere per capire 30.

Questo non significa che 30 LOC compressi in 8 righe saranno più facili da capire.

What do you think is the right way of doing things.

Normalmente in una funzione, cerco di raggrupparlo per livelli di astrazione ("codice IO qui", "convalida qui", "computazione qui" e così via).

Poi, l'ho diviso in blocchi, separati da una riga vuota. Se il codice è più di una decina di righe, estrao ogni blocco in una funzione diversa (lo faccio comunque per il codice che appare più di una volta). Ho sentito una discussione sull'interruzione delle prestazioni in questo modo (chiamate di funzioni non necessarie), ma in pratica non ho mai avuto un collo di bottiglia nelle prestazioni causato da questo.

Detto questo, ho avuto funzioni con questa estrazione fatta e dopo di essa la funzione era lunga circa 40 righe (codice C). Se il codice è il più raggruppato possibile, non vedo un problema con funzioni più lunghe.

    
risposta data 05.02.2013 - 12:12
fonte
2

Penso che sia più importante concentrarsi sul codice pulito e autodocumentato di LOC. Comunque non mi piace il tuo esempio, perché spiega cosa sta facendo il codice, senza dire perché. Ad esempio, questo:

booleano sweet_sixteen = (età == 16);

è abbastanza ridondante. Chiunque legga "età == 16" lo sa. Preferirei scrivere il codice in questo modo:

public static boolean companyShouldThrowABigParty(int age) {
    return (age == 16) || (age == 21) || ((age > 21) && (((age % 10) == 0) || ((age % 25) == 0))); 
}

public static void happyBirthday(int age)
{  
    System.out.println(companyShouldThrowABigParty(age) ? "Super special party, this year!" : "One year older. Again.");
}

La logica su come decidere quando lanciare la festa è separata dal System.out, può essere testata ed è facile da capire. Ancora più importante, però, qualcuno che legge il codice può capire il motivo per cui è stato scritto in quel modo ("la compagnia vuole organizzare una grande festa per alcune persone").

    
risposta data 06.01.2016 - 12:23
fonte
1

Penso che meno righe di codice = codice più leggibile

Ma ovviamente c'è un limite, quando inizi a minimizzare / oscurare il tuo codice solo per ottenere meno righe.

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

Questa è la minimizzazione, la logica rimane la stessa, solo meno leggibile. Questo non dovrebbe essere fatto dagli umani, questa minificazione è fatta dalla macchina per essere letta da una macchina.

function zP(e,t){var n=e+"";while(n.length<t){n="0"+n}return n}

Se riesci a rimuovere una parte di codice e l'algoritmo continua a fare ciò che dovrebbe fare, va bene. Basta non minimizzare il codice, ci sono strumenti migliori per farlo.

    
risposta data 05.02.2013 - 15:54
fonte
1

Non penso che meno righe di codice == codice più leggibile. Tuttavia, la realtà, che è molto diversa dalla teoria, è che il codice con un numero elevato di righe è spesso scritto senza un design adeguato. Di conseguenza, il requisito di un numero minore di righe PU MAY costringere alcuni programmatori a progettare meglio se sono in grado di farlo. La svolta è che molti programmatori non lo sono, quindi il requisito non aiuta molto.

    
risposta data 05.02.2013 - 19:19
fonte
1

Non vedrei il numero di linee come un problema in circostanze normali, ma può indicare problemi. Se qualcuno ti mostra una classe con 1000 righe di codice, allora qualcosa deve essere sbagliato nel modo in cui la classe è stata realizzata o progettata.

Il tuo esempio indica un caso in cui ha senso un numero maggiore di righe di codice. Ma questo è quell'esempio. Ogni giorno vedo esempi in cui il numero di righe è associato alla mancanza di pianificazione

    
risposta data 06.02.2013 - 20:21
fonte
0

LOC è una metrica più utile all'inizio di un progetto che durante l'effettiva implementazione, penso. Conoscere il LOC per punto funzionale ti permette di stimare lo sforzo del progetto, e da quello per quanto tempo il progetto prenderà e il numero ottimale di sviluppatori.

Può anche influenzare la scelta del design e della lingua: ridurre i punti di funzione o passare a una lingua con un LOC / FP inferiore dovrebbe ridurre lo sforzo del progetto, a parità di tutti gli altri.

    
risposta data 07.04.2013 - 05:02
fonte
0

Le linee di codice non sono molto importanti. Un modo per vederlo è confrontarlo con la prosa. La prima realizzazione è che una proprietà importante sia del codice che della prosa (assumendo la correttezza) è la leggibilità. La leggibilità (e la comprensibilità) aiuta con altre proprietà come la manutenibilità e la correttezza.

Ci sono dei vantaggi nell'essere in grado di adattare una funzione in un piccolo numero di linee. Ma avere testo senza paragrafi riduce la sua leggibilità. Usare concetti difficili, parole difficili (rare) e modi di espressione complessi generalmente riduce la quantità di parole necessarie per esprimere un'idea, ma allo stesso tempo sposta il livello di lettura del testo dal livello di scuola secondaria a quello accademico professionale (nel caso di prosa).

In generale è utile aggiungere astrazioni nel codice e utilizzare gli helper ecc. ma, ancora una volta, tali astrazioni possono diventare troppo numerose. Ciò che può anche accadere è spostare la complessità in un'altra parte del codice. A volte, come quando tu come esperto stai progettando un framework / libreria per i programmatori junior (o studenti), è una buona idea farlo. Ma non aspettarti che i ragazzi siano in grado di dare un senso a come funziona il tuo codice, ma è molto difficile per loro utilizzarlo in modo errato.

Durante la scrittura del codice, in particolare, non esitare ad aggiungere righe vuote nel codice. Funzionano come paragrafi e ti aiutano a separare diverse parti della tua funzione (anche se non dovrebbero essere ancora inserite in aiutanti).

    
risposta data 07.04.2013 - 19:51
fonte
-1

Il grande problema con ogni metodo formale di valutazione del codice è che sicuramente fallirà su qualche codice. Questo perché la programmazione è una sorta di arte e come tale, non possono esistere standard chiari per la valutazione. Ovviamente ci sono diversi tipi di arti - esiste anche la produzione di massa di dipinti, e forse in questo business è importante quante pitture vengono spese per un dipinto. :)

    
risposta data 05.02.2013 - 08:55
fonte
-1

Per essere perfettamente onesto, non mi fa fregare la misurazione della LOC. Certo, è bello per una funzione o una procedura essere il più breve possibile, ma prendo codice leggibile in breve in qualsiasi momento della giornata.

    
risposta data 22.10.2014 - 23:44
fonte
-2

Sono d'accordo sul fatto che richiedere sempre una riduzione di LOC porti a un codice difficile da leggere.

Tuttavia, forse il tuo stile di codifica è troppo prolisso e il tuo revisore pensa che sia meglio un modo più conciso. Ad esempio un commento che spiega solo una frase che è abbastanza ovvia grazie alla chiara scelta dei nomi delle variabili è inutile.

    
risposta data 05.02.2013 - 11:49
fonte
-2

C'è solo una cosa che le linee di codice misurano e questo è il numero di linee di codice che hai. Tutto il resto è aria calda, speculazione e pregiudizio.

Ci sono molti ottimi esempi nelle altre risposte su come avere meno linee di codice può fare qualcosa di peggio, non meglio, ma un punto centrale sembra essersi perso, e cioè: quante linee in realtà hai bisogno di per fare questo lavoro?

Se lo svolgimento del tuo compito richiede 10 linee di codice, così sia, lo fai in 10 righe. Se lo si realizza ha bisogno di 10.000 linee, quindi anche così sia, lo fai in 10.000 righe. Il culto di "meno righe di codice" non renderà l'ultimo esempio migliore se lo farai in 1.000 o 2.000 o qualsiasi altra cosa. Il lavoro necessario 10.000 linee e quelle 10.000 linee possono includere livelli di convalida, controllo degli errori, sicurezza, ecc. Che sarebbero persi se lo hai fatto in meno.

Modifica

Dato che questo ha raccolto qualche downvotes, penso di dover essere più specifico su ciò che sto dicendo qui. La prima cosa che chiunque dovrebbe fare è leggere questo - il punto che ti sto chiedendo di togliere è che il codice di alto livello che scrivi potrebbe avere poca o nessuna somiglianza con il codice macchina che viene effettivamente eseguito. La rilevanza di questo punto è che l'attenzione sul codice di alto livello senza una comprensione di ciò che accade in realtà è fuorviante.

Ora considera quanto segue:

  • È possibile scrivere codice veramente brutto, lento con una sola riga - annotare il commento sull'operatore ternario alla fine del link che ho fornito.

  • Se una linea di codice effettua una chiamata API (o un'altra chiamata in una libreria esterna), allora per definizione hai poco controllo diretto su cosa viene eseguito o quanto sia efficiente.

  • Il controllo degli errori, la pulizia, ecc. aggiungono linee aggiuntive di codice e sono abbastanza sicuro che anche il fan più accanito di un minor numero di righe di codice non discuti contro quelle .

Quindi - le linee di codice sono una metrica rotta. Meno linee di codice non garantiscono prestazioni extra: l'API o la chiamata di libreria è una riga e può essere al di fuori del tuo controllo. Meno linee di codice non garantiscono una maggiore robustezza: il controllo degli errori e la pulizia richiedono sempre linee aggiuntive. Meno linee di codice non garantiscono nemmeno leggibilità o manutenibilità aggiuntive: è sufficiente consultare IOCCC per saperlo.

Quindi cosa garantisce meno linee di codice? Meno linee di codice, tutto qui.

È profondamente sbagliato concentrarsi sullo stesso lavoro in 2.000 versi contro 10.000. Concentrati invece sul codice che funziona, che è robusto, che funziona all'interno delle tolleranze accettate e che è più facile da leggere e mantenere in futuro. A volte significa che puoi farlo con un conto LoC basso, a volte significa che devi farlo in un conteggio LoC più alto, ma il conteggio LoC non dovrebbe essere l'importante qui.

    
risposta data 11.06.2013 - 21:45
fonte
-3

Quanto è importante ridurre il numero di righe nel codice? Nella maggior parte dei casi, per niente. Infatti, nella maggior parte dei casi, è più importante aumentare il numero di righe di codice suddividendo operazioni complesse in passaggi più leggibili, commentando ogni passaggio e aggiungendo commenti in generale per rendere il codice più leggibile ed estensibile da altri sviluppatori che vengono dopo di te.

    
risposta data 05.02.2013 - 22:52
fonte
-5

Nel periodo precedente si presumeva che se il numero di linee di codice che è loc è grande allora il codice è efficace e realizza tutte le attività che è usato per fare ma è stato realizzato dopo un po 'che meno è il loc più ha l'efficienza come il costo sostenuto dal sistema nell'esecuzione del codice è molto meno. Quindi per il miglioramento del sistema loc doveva essere reso meno. Da allora si presumeva che il loc shoul fosse di meno. Per ridurlo i seguenti fattori dovrebbero essere presi in considerazione.

  1. Crea un diagramma di flusso del tuo problema
  2. Prova a utilizzare meno il numero di cicli possibile
  3. Le chiamate alle funzioni non dovrebbero essere molto
  4. Nuove strutture dati come TRIE dovrebbero essere utilizzate nel caso in cui lo stack o la coda vengano utilizzati per memorizzare le informazioni pertinenti.
  5. E cerca di risolvere il problema con un approccio realistico piuttosto che immaginativo in cui stai memorizzando una quantità enorme di numeri in un array molto grande e poi provi ad accedervi tramite l'array.]
  6. Utilizza quanti più macchi possibile Inoltre l'approccio da usare dipende anche dal problema. Se è davvero complesso, a volte usare l'approccio semplice equivale anche a quello complesso
risposta data 02.06.2013 - 03:34
fonte