Dovremmo incoraggiare stili di codifica a favore dell'autonomia dello sviluppatore o scoraggiarla a favore della coerenza?


15

Uno sviluppatore scrive if/elseblocchi con istruzioni di codice a una riga come:

if (condition)
   // Do this one-line code
else
   // Do this one-line code

Un altro usa parentesi graffe per tutti loro:

if (condition) 
{
   // Do this one-line code
}
else
{
   // Do this one-line code
}

Uno sviluppatore crea prima un'istanza di un oggetto, quindi lo utilizza:

HelperClass helper = new HelperClass();
helper.DoSomething();

Un altro sviluppatore crea un'istanza e utilizza l'oggetto in una riga:

new HelperClass().DoSomething();

Uno sviluppatore è più semplice con array e forloop:

string[] ordinals = new string[] {'First', 'Second', 'Third'};
for (i = 0; i < ordinals.Length; i++)
{
    // Do something
}

Un altro scrive:

List<string> ordinals = new List<string>() {'First', 'Second', 'Third'};
foreach (string ordinal in ordinals)
{
    // Do something
}

Sono sicuro che sai di cosa sto parlando. Lo chiamo stile di codifica (perché non so come si chiama). Ma come lo chiamiamo, è buono o cattivo? Incoraggiarlo ha un effetto su una maggiore produttività degli sviluppatori? Dovremmo chiedere agli sviluppatori di provare a scrivere il codice come diciamo loro, in modo da rendere l'intero sistema coerente con lo stile?


1
In realtà stavo venendo qui per porre una domanda molto simile proprio ora: quando gli strumenti di formattazione automatica del codice sono disponibili e convenienti, è più importante che tali strumenti non vengano eseguiti (e conservino stili personali incoerenti) o che venga applicato uno stile?
soffice

Lo stile coerente semplifica la lettura del codice, quindi utilizza uno stile coerente. Nei tuoi esempi, il più facile da leggere è 2, 1, 2. Sebbene l'ultimo caso sia diverso. Nelle applicazioni critiche per le prestazioni, il ciclo for è più veloce quando si scorre su elenchi. Le prestazioni sono identiche a quelle degli array. E in tutti i casi, utilizzare al varposto del nome del tipo completo.
Stephen,

Risposte:


19

Un documento sugli standard di codifica è utile. È molto utile quando è abbastanza corto da consentire a chiunque di ricordare tutto senza troppi problemi e quando non causa troppo dolore a nessuno.

Il modo in cui scegli di indentare il codice nella tua organizzazione, di scrivere in maiuscolo i nomi, di implementare i tuoi loop o di commentare il tuo codice non è poi così importante; la parte utile è far scrivere a tutti un codice simile a quello di tutti gli altri.

  • Evita di dover dedicare un minuto a ricalibrare le tue aspettative su dove dovrebbero essere le parentesi graffe e così ogni volta che guardi il codice di qualcun altro.
  • Evita di avere diversi stili di codice nello stesso file.
  • Forse ancora più importante, avere uno standard scritto evita argomenti sulle pratiche di codifica durante le revisioni del codice.

Ancora una volta, quali sono gli standard non importa tanto quanto avere una sorta di standard semplice e diretto. Quindi, metti tutti i tuoi sviluppatori in una stanza e lascia che discutano su quali dovrebbero essere gli standard. Questo incontro potrebbe durare indefinitamente, quindi le regole sono:

  • Tutto ciò che non viene deciso entro la fine della riunione sarà deciso dal gestore.
  • L'incontro terminerà dopo due ore, o quando qualcuno inizia a urlare o piangere, a seconda di quale evento si verifichi per primo.
  • L'intero standard si adatterà (di dimensioni ragionevoli!) Su un foglio o due di carta, fronte-retro solo se assolutamente necessario.

Valuta di adottare qualcuno | di | gli standard come punto di partenza per il proprio incontro sugli standard di codifica o come modo per evitare del tutto l'incontro.

Una volta concordato, gli sviluppatori dovrebbero essere in grado (e ci si dovrebbe aspettare che) poliziotti da soli. La deviazione occasionale dallo standard non dovrebbe essere un grosso problema (e potrebbe anche essere giustificabile), ma il rifiuto sprezzante di abbandonare uno stile personale preferito a favore dello standard dovrebbe comportare il trasferimento immediato in ufficio con le tubature dell'acqua che perdono, o qualsiasi altra cosa .

Demian Brecht indica strumenti per pelucchi. Questi sono un complemento perfetto per un documento sugli standard di codifica. È semplicemente buono attenersi agli standard di stile di codifica ; è importante attenersi agli standard di codifica relativi a pratiche pericolose. Nessun altro a parte l'autore verificherà che ogni riga di codice soddisfi lo standard di stile, ma dovresti certamente considerare la possibilità di creare uno strumento lanugine nel flusso di lavoro del tuo team per rilevare automaticamente i possibili bug. Inoltre, lo strumento stesso può codificare le pratiche accettate in modo da non doverle elencare tutte individualmente negli standard di codifica; basta specificare la configurazione dello strumento.

Nota: l'idea di "standard di codifica" non è esclusiva della programmazione. Gli "standard di codifica" sono utilizzati in molti campi, a volte all'interno di un'organizzazione, più spesso in un intero settore o professione. Qualche esempio:

In ogni caso (e molti altri) un professionista competente può facilmente comprendere "codice" che non soddisfa lo standard previsto. Perché così tante industrie continuano a scrivere requisiti dettagliati per i documenti che non hanno nemmeno bisogno di essere analizzati da un compilatore? Perché lo stile conta . La presentazione di informazioni in uno stile standard consente al lettore di concentrarsi interamente sul contenuto, rende più veloce la lettura e aiuta la comprensione e riduce gli errori.


1
Se aggiungi l'uso degli strumenti per la lanugine al tuo post, eliminerò il mio e +1 il tuo :)
Demian Brecht,

@DemianBrecht, buon suggerimento, grazie. Aggiunti strumenti per lanugine per migliorare la mia risposta, ma penso che dovresti lasciare anche la tua.
Caleb,

Bene allora. +1 comunque :)
Demian Brecht,

E anche a te!
Caleb,

+1 per il "... trasferimento immediato ..." come nella mia esperienza tale comportamento è coerente con le tendenze sociopatiche e / o narcisistiche, incompatibile con i team di sviluppo software.
Mattnz,

16

Lo stile non ha importanza.

Ecco, l'ho detto.

Dopo 30 anni e centinaia di siti di clienti e codice da (stimando) 500 (o più) membri del team in quegli anni, ho scoperto che lo stile non ha importanza.

Fallo funzionare prima.

Fai in modo che utilizzi un volume ottimale di risorse (ad es. Struttura dei dati corretta, algoritmo corretto).

Dimentica lo "stile" dopo che tutto il resto è stato risolto. Stupore di "stile" solo con strumenti, mai manualmente.


2
Amen! Gli standard di codifica devono essere giustificati in termini di reali benefici e la coerenza non è un vero vantaggio, ma un lusso.
JohnFx,

12
Ma lo stile riguarda raramente lo stile. Si tratta di evitare errori comuni.
Martin York,

6
Ma aiuta a evitare '=' invece di '==' (non usare l'assegnazione all'interno della condizione). Aiuta a evitare if (t) { x;y;}piuttosto che if (t) x;y;(usa sempre '{}' dopo if). Preferisci il codice const const (è molto difficile aggiungere la correttezza const al codice dopo che è stato scritto. Usa std :: cout / std :: cin non fprintf / scanf i primi hanno molte più probabilità di causare errori. Usa vector piuttosto che array (per evitare il trabocco).
Martin York,

5
Farla funzionare è ovviamente fondamentale. Ma solo perché funziona non significa che sia fatto. Deve anche essere testato. E poi rivisto. Che tutto ciò potrebbe richiedere alcuni giorni. Quindi, per anni dopo, deve essere letto, compreso e mantenuto. Il codice utile (perché scrivere di qualsiasi altro tipo?) Verrà letto molte più volte di quanto sia scritto, quindi facilitarne la lettura e la comprensione migliora la produttività in futuro. L'uso di uno stile coerente all'interno dell'organizzazione è un modo per aiutare in questo senso.
Caleb,

1
Che ne dici di imporre l'uso degli strumenti di formattazione automatica? Eclipse e XCode rendono molto semplice la formattazione del codice, ma uno degli ingegneri con cui lavoro diventa estremamente arrabbiato se qualcuno esegue automaticamente il "suo" codice (ovvero la società) per mantenerlo coerente con il resto della base di codice. La formattazione è solo una piccola parte dello stile, ma è anche importante, soprattutto per problemi come l'annidamento if / else e il flusso di codice generale (per non parlare della leggibilità).
soffice

4

Esistono stili di codifica e odori di codifica. Non è stato una volta che ho trovato:

    if(debugCondition)
//         printf("DEBUG: state:%s at debugCondition\n",dbg_state());

    for(i=0; i<MAX;i++)
    {
       //some essential business logic
    }

Il mio precedente datore di lavoro ha rigorosamente vietato l'uso di multiline if()senza parentesi graffe. È stato considerato un errore di tipo "fallo di nuovo e sei licenziato". I costrutti consentiti erano

     if(condition) break; 
     if(condition) continue; 
     if(condition) return; 
     if(condition) for()...; 

Ciò è derivato da un errore proprio come quello che ho mostrato sopra, che ha impiegato un paio d'ore per arrestare la pagina principale del portale.

Ci sono cose che dovresti sempre fare. Come switch():

     case 1:
         something();
     break;
     case 2:
         something();
     return;
     case 3:
         something();
     continue;
     case 4:
     case 5:
         something();
     break;
     case 6:
         something();
     //fallthrough;
     case 7:
     ...

Nel frattempo, digitando:

     case 1:
         something();
     case 2:
         something();
     break;

senza chiudere un casecon //fallthroughè considerato un bug.

In generale, esiste lo standard di codifica che è le linee guida che possono essere ignorate, interpretate in modo creativo o modificate per determinate esigenze. E c'è la sezione sugli "odori" e deve essere rigorosamente rispettata.


3

Crea coerenza con un buon design iniziale. Quello che descrivi nella domanda non è altro che la micro-gestione. Faccio molto sviluppo web. Quindi preferisco lo sviluppo RESTful e CRUD esposto come servizi. Ciò garantisce entità semplici e ben definite che possono essere utilizzate in vari modi.

Questo design mi consente anche di delegare i dettagli dell'implementazione ad altri sviluppatori. In questo modo stanno riempiendo gli spazi vuoti piuttosto che creare un intero sistema di progettazione.

La mancanza di un design generale crea incoerenze nel sistema. La critica delle iterazioni di base e dei costrutti di loop non fa molto per migliorare la progettazione del sistema. Questi tipi di problemi vengono risolti meglio con un approccio senza mani, StyleCop.

Riesci a disegnare un diagramma relativamente semplice della progettazione generale del tuo sistema? Un disegno che descrive gli elementi / entità coinvolti in un nuovo sviluppatore del team. Se non puoi, o è fortemente coinvolto, il design è carente.


3

IMHO dipende ...

I tuoi primi due esempi non sono solo una questione di gusti personali per me.

if (condition)
   // Do this one-line code
else
   // Do this one-line code

(senza parentesi) = più soggetto a bug, se più codice verrà aggiunto in seguito:

if (condition)
   // Do this one-line code
else
   // Do this one-line code
   // ...and this line as well... oops! this will actually execute either way

E questo è meno conveniente per il debug:

new HelperClass().DoSomething(GetSomeData()); // etc.

Non puoi semplicemente impostare un punto di interruzione dove ne hai bisogno. Se questo è una tantum - abbastanza giusto, ma ne discutiamo come una questione di stile, e una volta che hai roba del genere dappertutto, il debug diventa più spiacevole di quanto dovrebbe essere.

Per quanto riguarda il tuo terzo esempio (per vs foreach), però lo vedo come una questione di gusti.


2

Né. Eviterei regole di codifica rigide per evitare di essere noioso, pignolo, micro gestionale e il peggio di tutto il tempo perso. Il tuo senso di autonomia è il tuo problema. Se voglio che tu ti senta meglio con te stesso, ti comprerò un giro della tua bevanda preferita. A parte questo, fai qualcosa.


2

L'uso di convenzioni, nomi di variabili, nomi di classe ecc. È una buona pratica. Ma gli stili di codifica come gli esempi forniti sono piuttosto banali e non hanno alcun effetto sulla leggibilità o sull'efficienza del codice. D'altro canto, il sovraccarico derivante dall'applicazione di un determinato stile unito allo sforzo degli sviluppatori di seguirlo causerà problemi.


2

Usa uno strumento per linting standard (apparentemente FxCop per C #). Anche se non è la fine del tutto, la coerenza è importante nei grandi progetti che hanno un numero di persone che ci lavorano.

Se stai solo lavorando sul tuo progetto o su un piccolo team, molti direbbero che è eccessivo. Credo diversamente (utilizzo PEP8 per Python, anche nei miei progetti personali per sviluppatori singoli).

La maggior parte degli esempi che hai fornito, tuttavia, molto probabilmente non verrebbero catturati da uno strumento di lanugine poiché semplicemente non contano.


1

Applicare uno stile di codifica uniforme è sempre difficile. Idealmente tale compito banale dovrebbe essere lasciato a uno strumento da gestire. Mi congratulo con la comunità linguistica Go per averlo fatto.


1

È una miscela di entrambi. Solo perché è uno standard non lo rende leggibile e mantenibile. Se non esiste ancora uno standard instillato o se vi sono aspetti difettosi e illeggibili, la revisione è appropriata.


1

In ultima analisi, è il programmatore che guida la programmazione. Esistono problemi di stile, ma sono secondari per far uscire il programma.

È utile fornire ai programmatori ALCUNI consigli di stile. Questo può / dovrebbe essere fatto prima che i programmatori siano messi al lavoro, specialmente se sono principianti relativi all'ambiente o alla programmazione stessa. Data la guida, alcuni programmatori saranno molto attenti allo stile, altri meno. Le indicazioni fornite all'inizio del progetto aiuteranno il primo gruppo di programmatori, facilitando così il compito generale. Potrebbe fare ben poco per il secondo gruppo, che si spera (si spera) in creatività, ciò che manca in conformità.


1

Penso che dipenda dalle dimensioni del progetto e da quante persone ci stanno lavorando. Un programmatore esperto può esaminare entrambi gli stili di formato diversi e sapere cosa stava succedendo in entrambi, ma è necessario che ci sia una vaga impressione in modo che l'occhio possa catturarlo facilmente. Se hai intenzione di fare i tuoi ifstatments a linea singola senza le parentesi graffe allora quel progetto non dovrebbe usarli Chi mai dirige quel progetto dovrebbe avere quella scelta. Mi piace che le cose appaiano chiare e anche molto compatte, come posso ottenerle. Se hai intenzione di fare una linea singola se statmeents è meglio che sia così

if() {}
else() {}

O anche:

if() {} else () {}

Ma una sola riga non dovrebbe usare la spaziatura di una mulitilina se. È proprio come faccio le cose. Non mi dispiace il modo in cui l'oggetto viene chiamato e ciò dipende da quante volte viene chiamato. se viene chiamato alcune volte allora preferisco avviare l'oggetto e dipende se ha i costruttori e cosa no. Perché se hai un costruttore e chiami:

Object.method();
Object.method2();

Quindi hai finito di chiamare due volte il metodo costellazione oggetto quando avrebbe potuto essere evitato installando l'oggetto completamente.

Quando si tratta di foreach e di loop Si tratta anche di lanauge, alcune lanauges ti danno un migliore controllo quando guardi l'array in un loop foreach in modo da avere la chiave e il valore negli array temp. E so che alcune lingue hanno una sorta di ottimizzazione perché possono guardare il ciclo e sapere esattamente quante volte verrà chiamato.


1

Mentre il tuo primo esempio non è eccezionale (l'argomento secondo cui è più soggetto a bug sotto modifica ha un certo peso), in generale sono effettivamente cresciuto per preferire che gli sviluppatori usino stili di codifica leggermente diversi.

Dopo aver lavorato con il codice di altri membri del team, a volte anche per pochi mesi, inizia essenzialmente a lavorare in linea git blame. Dopo essere stato nella mia azienda per oltre 10 anni, probabilmente posso dirti con una precisione dell'80% + chi ha scritto una determinata classe in qualsiasi punto delle nostre 500k righe di codice, semplicemente guardandolo.

Mentre c'è un po 'di "tempo di rampa" quando inizi a guardare il codice che utilizza uno stile con cui non sei d'accordo, quello che stai davvero facendo in quel momento è dire "oh, sembra il codice di John Doe (perché usa lo stile X ma non lo stile Y, ecc.) ". E questo porta con sé un mucchio di contesto. Per una prima approssimazione, sai cosa aspettarti dal codice di John - quali altre parti della base di codice capisce bene e quali parti non capisce, se è un guru di SQL o un novizio della GUI, ecc. Ecc.

L'esecuzione del codice di tutti attraverso un formattatore essenzialmente elimina queste informazioni, nascondendole dietro a git blame, che potresti non preoccuparti di eseguire.


0

Questo dipende molto dal tipo di organizzazione.

Se sei un piccolo gruppo di supereroi, allora qualsiasi tipo di stile va bene. Se ognuno ha il proprio stile ed è sia buono che coerente internamente, allora è tutto il processo di cui hai bisogno. I Supereroi diranno "Jane ha parentesi, quindi questo è ciò che intende" o "Jack usa camelCase per le variabili".

Gli standard universali tendono ad essere i migliori per rendere tutti un giocatore B +. I tuoi supereroi verranno abbattuti da questo. Ma se vuoi un giocatore A e una mezza dozzina di giocatori B e una mezza dozzina di giocatori C in media fino al B +, allora vuoi standard coerenti. In questo caso, vuoi che tutti facciano le cose allo stesso modo in modo che il giocatore A possa esaminare il codice di tutti il ​​più rapidamente possibile.

Molti di voi pensano: "Ma aspettate, perché non eliminare i giocatori B e C?"

La realtà è che non ci sono molti supereroi. Sebbene possa essere utile trovarli e nutrirli su Google, l'inserimento di un nuovo sistema di fatturazione per Ma Bell potrebbe essere più conveniente con quest'ultima squadra. (E se hai davvero Supereroi, 4 o 5 di loro saranno due volte più costosi di una dozzina di junior)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.