Il limite di 80 caratteri è ancora rilevante in tempi di monitor widescreen? [chiuso]

su un monitor widescreen si possono facilmente vedere più di 80 caratteri alla volta, senza barre di scorrimento. anche Linus Torvalds vede il limite di 80 caratteri obsoleto .

quindi, il limite di 80 caratteri è ancora rilevante in tempi di monitor widescreen?

Esistono diversi motivi per aderire ancora a un limite di 80 caratteri (o, un limite di 74 caratteri è ancora migliore; consente al codice di rimanere meno di 80 colonne anche quando vengono aggiunti marcatori diff e quotazione e-mail, se si esegue la revisione del codice su mailing list).

Anche nell'era dei monitor widescreen, mi piace avere diverse finestre aperte affiancate, che mostrano diverse parti del codice. Ad esempio, di solito ho un browser Web ed e-mail aperti su uno schermo e due file e un terminale aperti fianco a fianco su un secondo monitor. Se hai linee che corrono su 80 colonne, devi avere a che fare con l'editor che le avvolge (il che è brutto e rende il codice più difficile da navigare) o allarga le finestre in modo tale da non poterle inserire tutte sullo schermo in una volta.

Anche se di solito non modifichi in questo modo, se usi mai uno strumento diff side-by-side, apprezzerai i file con lunghezze di linea ragionevoli che renderanno il tuo diff più facile da visualizzare.

C'è anche un problema di densità del codice. Mi piace avere un sacco di contesto durante la lettura del codice. È molto, molto più veloce guardare su e giù per una finestra piuttosto che scorrere. Se hai linee molto lunghe, tendi anche ad avere linee che variano molto in lunghezza, portando a un sacco di spazio sullo schermo sprecato e in grado di adattare meno codice sullo schermo in un dato momento complessivo.

E infine, se hai linee molto lunghe, ciò significa generalmente che hai linee molto complicate, indendenza profonda o che hai identificatori molto lunghi. Tutti questi possono essere un problema. Le linee complicate probabilmente stanno facendo troppo; se riesci a scomporlo in più righe più semplici, probabilmente dovresti. Il rientro profondo significa che probabilmente stai annidando troppi loop e condizionali, il che può rendere confuso il flusso del codice; considerando il refactoring in diverse funzioni. E se i tuoi identificatori sono troppo lunghi, può rendere molto difficile la lettura del codice. Le persone generalmente riconoscono le parole come singole unità; non leggono tutti i personaggi uno per uno, ma guardano la forma generale della parola. Gli identificatori lunghi sono più difficili da distinguere in questo modo e di solito, se sono così lunghi, contengono informazioni ridondanti o ripetitive.

Ora, mentre è ancora buona prassi mantenere il codice al di sotto di 80 colonne, questa non è una di quelle regole che devono essere seguite religiosamente, contorcendosi per adattarsi a una linea quando non lo fa. Ti suggerisco di provare a mantenere tutto il tuo codice sotto 80 colonne, ma quando non si adatta, non preoccuparti troppo.

Se mantengo le mie righe a meno di circa 100 caratteri, posso avere due finestre dell'editor affiancate su un monitor widescreen. È molto utile avere entrambi il file di intestazione della classe e l'implementazione entrambi visibili contemporaneamente o avere il codice da un lato che chiama il codice dall'altro. E, se mantengo le linee corte, non ho bisogno di una barra di scorrimento orizzontale sulle finestre del mio editor, che mi dà più spazio verticale.

80 personaggi potrebbero essere obsoleti, ma c'è qualche merito nel mantenere le cose entro limiti ragionevoli.

Non penso che il monitor abbia nulla a che fare con esso - almeno non più.

Se non riesci a codificare una riga di 80 caratteri, probabilmente è comunque un segno di codice errato. Espressioni troppo complesse. Rientro troppo profondo. ecc. Dovresti fermarti e ripensare a ciò che stai facendo.

Ma se sei sicuro che il codice richiedesse più di 80 righe, vai avanti e fallo. Penso che sia meglio avere un codice che superi gli 80 caratteri piuttosto che aggiungere cambiamenti idiomatici solo per ridurlo.

Personalmente odio questo tipo di cose:

ret = my_function(parameter1, \
                  parameter2, \
                  parameter3, parameter4);

Invece semplicemente:

ret = my_function(parameter1, parameter2, parameter3, parameter4);

Alla codifica?

Certamente si. L'essere umano normale non è in grado di leggere bene troppo in largo. Con poche colonne muovi meno gli occhi, ti concentri meglio e ritardi la stanchezza. È un guadagno minimo ma importante.

Sì, ci sono motivi per limitare la lunghezza della riga di codice:

1. Sebbene le nostre schermate si siano allargate, a volte è necessario stampare il codice. Se solo per questo motivo .
2. I diff-viewer visualizzano spesso le linee con una divisione verticale - questo diventa più difficile se le linee sono lunghe quanto lo consentirebbe uno schermo largo.

Detto questo, 80 è un po 'troppo piccolo. Tuttavia, qualche limitazione è probabilmente una buona idea come principio di progettazione.

Direi che le righe extra lunghe non dovrebbero essere vietate, perché occasionalmente sono necessarie. Ma se la maggior parte delle funzioni è visualizzabile solo su uno schermo da 30 ", il codice presenta alcuni problemi.

È arbitrario, ma esiste un limite non arbitrario a ciò che è facile da leggere. Trovo che colonne di testo molto ampie siano molto difficili da scansionare e leggere, indipendentemente dal fatto che siano codice o prosa. Inoltre, come hanno sottolineato molte altre risposte, non è come se questo codice fosse l'unica cosa sullo schermo. È bello avere due o più finestre di codice contemporaneamente e inserirle su un monitor wide screen.

Probabilmente non è rilevante scegliere esattamente un limite di 80 caratteri; cosa cambierebbe se il limite fosse 85, per esempio?

È vero che i monitor usati al giorno d'oggi hanno risoluzioni più elevate, ma in un editor di testo / IDE, non tutto lo spazio viene preso dalla vista di testo; nell'editor che uso mostra a sinistra l'elenco dei file inclusi nel progetto.

La risoluzione utilizzata in un netbook o in un notebook non è la stessa utilizzata nei monitor; probabilmente ha senso usare un limite di caratteri che non crea "problemi" a nessuno.

Dipende davvero dall'ambiente di sviluppo.

Ad esempio, in una grande società con migliaia di sviluppatori, ci sono probabilmente centinaia di persone che, nel corso della vita di un prodotto, dovranno esaminare una parte del suo codice. Con così tante persone, ci saranno sicuramente poche persone che, per qualsiasi motivo (hardware più vecchio, netbook, ecc.) Operano a 800x600 o più piccole. C'è qualche valore nel soddisfarli.

Nella mia compagnia di 25 persone, però, dico di fotterlo. Stiamo tutti usando due moderni monitor alla massima risoluzione - 120-140 o così è la linea guida informale.

Avere qualche limite ha sicuramente senso. Ma il limite di 80 caratteri è troppo vincolante. Preferisco qualcosa come un limite di 96 caratteri. È abbastanza largo per la maggior parte del codice con cui ho a che fare ed è abbastanza stretto in modo che due file possano essere messi fianco a fianco per il diff (su un ampio schermo).

Credo che la leggibilità del codice superi tutte le altre preoccupazioni. E con 96 caratteri per codice di riga può essere reso molto più leggibile che con 80.

Non compro l'argomento secondo cui la maggior parte delle persone imposta i propri terminali su 80 caratteri di larghezza, no che le stampanti debbano avvolgere linee più lunghe di 80 caratteri. Non è un limite difficile come in passato (distante). È possibile impostare facilmente il terminale e la larghezza della stampante su 100 caratteri.

No, non è più rilevante:

• La maggior parte dei caratteri utilizzati nelle applicazioni e sul Web non ha comunque una larghezza fissa. In altre parole, 80 caratteri! = 80 caratteri.
• Come hai detto, la larghezza dello schermo è cambiata: 80 caratteri non sono un limite sensibile.

80 caratteri erano in realtà una linea guida per i caratteri a larghezza fissa in un ambiente console.

Certo, se stai ancora usando un carattere a larghezza fissa in un ambiente console ... allora certo, 80 caratteri sono sensati :)

Se si utilizza un editor in una GUI, gli 80 caratteri per riga sono irrilevanti, dal momento che la maggior parte degli editor decenti - ad esempio Notepad ++ - ha un pulsante per attivare / disattivare il ritorno a capo. Con ciò, non dovrebbe essere un problema, anche quando si visualizza il codice in una finestra sottile.