Cosa definisce la leggibilità del codice? [duplicare]

La leggibilità, per me, significa che il codice è facile da seguire, logicamente.

1. Vengono seguiti gli standard di indentazione e formattazione, in modo che il codice e la sua struttura siano chiaramente visibili.
2. Le variabili sono nominate in modo significativo, in modo che comunichino l'intento.
3. I commenti, che sono presenti solo dove necessario, sono concisi e aderiscono ai formati standard.
4. Vengono utilizzate clausole di protezione invece di istruzioni nidificate if
5. Le funzionalità del linguaggio vengono utilizzate abilmente, sfruttando l'iterazione e la ricorsione piuttosto che copiare e incollare la codifica.
6. Le funzioni sono brevi e al punto, e fanno una cosa .
7. L'indirizzamento è ridotto al minimo il più possibile, pur mantenendo la flessibilità.

illeggibile :

        try:
          if item[1][2]=='1':
            qtytype='0'
            qty=str(item[1][0])
            items=item[1][0]
            amt='0.0'
            tot_amt=str(float(item[1][1])/100)
#              tot_amt=str(float(int(item[1][0])*int(item[1][1]))/100)
          else:
            qtytype='1'
            items=item[1][0]
            amt='0.0'
            tot_amt=str(float(item[1][1])/100)
            qty=0
            for entry in item[1][4]:
              qty+=entry[0]
        except TypeError:
          eType, eValue, eTraceback = sys.exc_info()
          print >> sys.stderr, time.strftime("%Y-%m-%d %H:%M:%S"), str(traceback.format_exception(eType,eValue,eTraceback))

leggibile:

item_approved = (item['approved'] == '1' and item['active'] == '1')

if item_approved:
    try:
        db_item = item.get_db_record(item['id'])
    except DoesNotExist:
        db_item = item.create_db_record(**item)

    item.approve(db_item)
    db_item.save()

    publish_event(item.events.APPROVAL)

La sezione 9 (pg 39) del link fornisce alcune informazioni di base per le linee guida sulla codifica del linguaggio C. È un lavoro di riferimento con sociologia e studi di psicologia. Si sta affrontando di più la domanda "perché il codice dovrebbe essere leggibile", ma si rivolge direttamente alla leggibilità. L'ho trovato piuttosto interessante, anche se un po '"accademico" nei luoghi.

Domande simili hanno avuto risposta prima. Ad esempio link .

Il codice leggibile è un codice che comunica chiaramente la sua intenzione al lettore. Il codice che non è leggibile richiede più tempo per comprendere e aumenta la probabilità di difetti.

Alcune cose che aumentano la leggibilità:

1. Usa gli spazi bianchi per separare le aree di codice più disparate. Ad esempio, il codice di rientro si blocca come le istruzioni "if". Lasciare linee vuote tra metodi / funzioni o righe di codice correlate all'interno di un metodo / funzione. Ciò consente al cervello di separare il codice ancor prima che i caratteri vengano letti.
2. Utilizza variabili significative e nomi metodo / funzione / classe. Seguire la pratica standard per la lingua e, se possibile, utilizzare termini del dominio problematico. Il significato e l'uso di qualcosa dovrebbero essere evidenti dal suo nome. I nomi dovrebbero essere coerenti (GetX (), GetY () e GetZ () piuttosto che get_X (), LoadYFromDatabase () e getVar (Fields.Z));
3. Commento efficace. Evita commenti ovvi ("Il metodo GetX () restituisce il valore corrente di x"). I commenti dovrebbero dire cosa intende fare il codice, come si relaziona con altre parti del codice e qualsiasi ipotesi ("Argomento" a "non può essere nullo. Il codice genera un'eccezione se a è null").
4. Seguendo i modelli di progettazione stabiliti per la lingua, la biblioteca o lo spazio dei problemi. Ad esempio, evitare di ripetere codice (chiamato DRY o Do not Repeat Yourself). Questo fa perdere tempo mentre il lettore cerca di individuare le differenze o trova il codice corretto da correggere.
5. Keep it Simple (principio KISS). Ad esempio, evitare l'ottimizzazione prematura o non necessaria. L'ottimizzazione ha il suo posto, ma il codice può spesso essere ottimizzato senza influire sulla leggibilità.

Probabilmente il singolo aspetto più importante è la coerenza. È più facile capire il codice se il lettore sa cosa aspettarsi e dove cercare. Se il progetto utilizza stili di denominazione e commento variabili in conflitto, ad esempio, il lettore deve sprecare energie per imparare nuovi stili e cambiare contesto.

L'autore del codice può essere un pessimo giudice della leggibilità poiché potrebbe essere investito nel codice o essere troppo in profondità nel problema per fare un passo indietro e guardarlo attraverso gli occhi degli altri. Le recensioni dei codici aiutano qui.

Ricorda che non tutto il codice sarà sempre leggibile. Gli sviluppatori spesso devono scrivere codice in fretta quando sono stanchi di usare librerie sconosciute. La scarsa leggibilità dovrebbe essere trattata come debito tecnico e refactored.