Ciò che rende il codice Perl mantenibile?

StackOverflow https://stackoverflow.com/questions/4349142

  •  30-09-2019
  •  | 
  •  

Domanda

ho scritto in Perl da diversi anni ed è la mia lingua preferita per l'elaborazione del testo (molte delle genetica / genomica problemi su cui lavoro sono facilmente ridotti a problemi di elaborazione testo). Perl come linguaggio può essere molto indulgente, ed è possibile scrivere molto povera, ma funzionale, il codice in Perl. Proprio l'altro giorno, il mio amico ha detto che lui chiama Perl un di sola scrittura lingua:. Scrittura una volta, capire una volta, e mai e poi mai cercare di tornare indietro e risolvere il problema dopo che è finito

Mentre ho sicuramente stato colpevole di scrittura di script male a volte, mi sento come Ho anche scritto qualche codice molto chiara e gestibile in Perl. Tuttavia, se qualcuno mi ha chiesto che cosa fa il codice chiaro e mantenibile, non sarebbe in grado di dare una risposta sicura.

Ciò che rende il codice Perl mantenibile? O forse una domanda migliore è ciò che rende il codice Perl difficile da mantenere? Supponiamo che io non sono l'unico che sarà mantenere il codice, e che gli altri contribuenti, come me, sono i programmatori non professionali del Perl, ma scienziati con esperienza di programmazione.

È stato utile?

Soluzione

Ciò che rende il codice Perl impossibile da mantenere? Praticamente tutto ciò che rende qualsiasi altro programma impossibile da mantenere. Supponendo che qualcosa di diverso da un breve script destinato a svolgere un compito ben definito, questi sono:

  • Le variabili globali
  • La mancanza di separazione degli interessi: script monolitici
  • NON utilizzando identificatori auto-documentazione (i nomi delle variabili e nomi di metodo). Per esempio. si dovrebbe sapere che scopo di una variabile è dal suo nome. Bad $c. $count meglio. buona $token_count.
    • Spell identificatori fuori. dimensione del programma non è più una preoccupazione fondamentale è.
    • Una subroutine o metodo chiamato doWork non dice niente
    • Lo rendono facile trovare la fonte di simboli da un altro pacchetto. O utilizzare il prefisso package esplicito, in modo esplicito o importare ogni simbolo utilizzato tramite use MyModule qw(list of imports).
  • Perl-specifica:
    • Eccessivo affidamento su scorciatoie e le variabili incorporate oscuri
    • Abuso di subroutine prototipi
    • non usare strict e che non utilizzano warnings
  • reinventare la ruota, piuttosto che utilizzando librerie stabilite
  • Il mancato utilizzo di uno stile di indentazione coerente
  • Non utilizzare spazi vuoti orizzontale e verticale per guidare il lettore

ecc ecc ecc.

In sostanza, se si pensa Perl è -f>@+?*<.-&'_:$#/%! , e si aspira a cose scrittura del genere nel codice di produzione, allora, sì, avrete problemi.

Le persone tendono a confondere roba Perl programmatori fare per divertimento (ad esempio, JAPHs, golf, ecc) con quello che un buon programmi Perl si suppone a guardare come.

Sono ancora poco chiare su come essi sono in grado di separare nelle loro menti codice scritto per IOCCC da mantenibile C.

Altri suggerimenti

Suggerisco:

  1. non troppo intelligente con il Perl. Se si inizia a giocare a golf con il codice, sta andando a tradursi in codice più difficile da leggere. Il codice che si scrive deve essere leggibile e chiaro più che ha bisogno di essere intelligente.
  2. Documento del codice. Se si tratta di un modulo, aggiungere POD che descrive l'utilizzo e metodi tipici. Se si tratta di un programma, aggiungere POD per descrivere le opzioni della riga di comando e l'utilizzo tipico. Se c'è un algoritmo peloso, documenti e fornire i riferimenti (URL), se possibile.
  3. Utilizza il modulo /.../x di espressioni regolari, e li documento. Non tutti capiscono bene regex.
  4. Sapere cosa accoppiamento è, e i pro / contro di alto / basso accoppiamento.
  5. Sapere cosa è la coesione, e i pro / contro di alta / bassa coesione.
  6. Uso moduli opportunamente. Un bel ben definito, concetto ben-contained fa un grande modulo. Il riutilizzo di tali moduli è l'obiettivo. Non utilizzare moduli semplicemente quello di ridurre le dimensioni di un programma monolitico.
  7. unit test del codice scrivere per voi. Una suite di test buona non solo permetterà di dimostrare il codice è oggi al lavoro, ma domani pure. Essa vi permetterà anche di apportare modifiche più audaci, in futuro, con la sicurezza che non si sta rompendo le applicazioni meno recenti. Se si fanno le cose pausa, poi, beh, la vostra suite test non era sufficientemente ampia.

Ma in generale, il fatto che si cura abbastanza di manutenzione ad una domanda su di esso, mi dice che siete già in un buon posto e di pensare nel modo giusto.

Non faccio uso di tutti Perl Best Practices , ma questo è il cosa che Damian ha scritto per. O se non lo uso tutti i suggerimenti, sono tutti vale la pena almeno prendere in considerazione.

  

Ciò che rende il codice Perl mantenibile?

Al minimo: 

use strict;
use warnings;

perldoc perlstyle per alcune linee guida generali che renderanno i vostri programmi più facili da leggere, capire, e mantenere.

Un fattore molto importante per la leggibilità del codice che non ho visto detto in altre risposte è l'importanza dello spazio bianco, che è sia Perl-agnostico e in un certo senso Perl-specifici.

Perl permette di scrivere codice molto conciso, ma pezzi Consise non significa che devono essere tutti raggruppati insieme.

Lo spazio bianco ha un sacco di significato / uso quando si parla di leggibilità, non tutti ampiamente utilizzati, ma più utili:

  • Gli spazi attorno gettoni di più facile li separano visivamente.

    Questo spazio è doppiamente importante in Perl a causa della prevalenza di personaggi di rumore anche in linea di best-stile codice Perl.

    Trovo $myHashRef->{$keys1[$i]}{$keys3{$k}} di essere meno leggibile alle 2 di notte nel bel mezzo di emergenza producion rispetto al distanziati: $myHashRef->{ $keys1[$i] }->{ $keys3{$k} }.

    Come nota a margine, se si trova il codice di fare un sacco di profonde espressioni di riferimento nidificate tutti a partire con la stessa radice, si dovrebbe assolutamente prendere in considerazione l'assegnazione che la radice in un puntatore temporaneo (vedi di Sinan commento / risposta).

    Un caso particolare parziale ma molto importante di questo è di espressioni regolari naturalmente. La differenza è stata illustrata a morte in tutti i principali materiali che ricordo (PBP, RegEx O'Reilly libri, ecc ..), quindi non voglio allungare questo post ancora di più a meno che le richieste di qualcuno esempi nei commenti.

  • Una corretta ed uniforme indentazione. D'oh. Ovviamente. Eppure vedo modo troppo codice 100% a causa illeggibile al rientro scadente, e ancor meno leggibile quando la metà del codice è stato rientrato con le schede da una persona il cui editor utilizzato 4 schede dei personaggi e un altro da una persona il cui direttore usato 8 TAB carattere. Basta impostare il vostro editor sanguinosa fare molli (ad esempio spazio-emulato) TAB e non fare altri infelici.

  • righe vuote unità intorno logicamente separate di codice (entrambi i blocchi e solo set di linee). È possibile scrivere un programma Java 10000 linea in 1000 linee di buona Perl. Ora non si sentono come Benedict Arnold se si aggiungono 100-200 righe vuote a quelle 1000 a rendere le cose più leggibile.

  • Splitting espressioni uber a lungo in più righe, seguita da ...

  • allineamento verticale corretto. Testimone la differenza tra: 

    if ($some_variable > 11 && ($some_other_bigexpression < $another_variable || $my_flag eq "Y") && $this_is_too_bloody_wide == 1 && $ace > my_func() && $another_answer == 42 && $pi == 3) {

    e 

    if ($some_variable > 11 && ($some_other_bigexpression < $another_variable || 
    $my_flag eq "Y") && $this_is_too_bloody_wide == 1 && $ace > my_func()
    && $another_answer == 42 && $pi == 3) {

    e 

    if (   $some_variable > 11
    && ($some_other_bigexpression < $another_variable || $my_flag eq "Y")
    && $this_is_too_bloody_wide == 1
    && $ace > my_func()
    && $another_answer == 42
    && $pi == 3) {

    Personalmente, preferisco fissare l'allineamento verticale di più ad un passo dal LHS allineamento e RHS (questo è particolarmente leggibile in caso di query SQL lunghe, ma anche nel codice Perl stesso, sia le lunghe condizionali come questo così come molte linee di assegnazioni e inizializzazioni hash / array): 

    if (   $some_variable               >  11
    && ($some_other_bigexpression   <  $another_variable || $my_flag eq "Y")
    && $this_is_too_bloody_wide    ==  1
    && $ace                         >  my_func()
    && $another_answer             ==  42
    && $pi                         ==  3  ) {

    Come nota a margine, in alcuni casi, il codice potrebbe essere reso ancora più leggibile / mantenibile non avendo tali espressioni lunghe, in primo luogo. Per esempio. se il contenuto del blocco if(){} è un return, quindi facendo più istruzioni if/unless ognuno dei quali ha un blocco di ritorno può essere migliore.

Io vedo questo come un problema di persone viene detto che perl è illeggibile, e cominciano a fare ipotesi circa la maintability del proprio codice. se siete abbastanza coscienza di prendere in considerazione la leggibilità come un marchio di garanzia di qualità del codice, è probabile che questa critica non si applica a voi.

maggior parte delle persone citare espressioni regolari quando discutono leggibilità. regex sono un dsl incorporato in perl e si può sia leggerli o no. se qualcuno non può prendere il tempo di capire qualcosa di così fondamentale ed essenziale per molte lingue, io non sono preoccupato per cercare di colmare qualche lacuna cognitiva dedotto ... dovrebbero solo uomo, leggere le perldocs, e fare domande, se necessario, .

altri si citano l'uso di Perl di forma breve vars come @_, $! ecc Questi sono tutti facilmente disambiguare ... io non sono interessato a fare aspetto perl come Java.

Al rialzo di tutte queste stranezze e perlisms è che basi di codice scritte in lingua sono spesso terso e compatto. preferirei leggere linee dieci di perl di un centinaio di linee di Java.

per me non c'è molto di più a "manutenibilità" che semplicemente avendo un facile da leggere il codice. test di scrittura, le asserzioni di make ... fanno tutto il resto si può fare per appoggiarsi perl e il suo ecosistema per mantenere il codice corretto.

In breve:. Programmi di scrittura per essere il primo corretta, quindi fissare, quindi con buone prestazioni .... una volta che questi obiettivi sono stati raggiunti, poi preoccuparsi che lo rende bello rannicchiarsi con vicino un fuoco

direi i modelli di imballaggio / oggetto, che si riflette nella struttura di directory per i file .PM. Per il mio dottorato ho scritto un sacco di codice Perl che ho riutilizzare in seguito. Fu per generatore automatico diagramma LaTeX.

parlerò alcune positivi cose per rendere Perl gestibile.

E 'vero che di solito non dovrebbe ottenere troppo intelligente con dichiarazioni davvero densi alla return !$@;#% e simili, ma una buona quantità di operatori di lista-elaborazione utilizzando intelligenti, come map e ritorna grep e la lista al contesto del calibro di split e operatori simili, al fine di scrivere il codice in uno stile funzionale in grado di dare un contributo positivo alla manutenibilità. Al mio ultimo datore di lavoro abbiamo avuto anche alcune funzioni hash sgargianti di manipolazione che hanno lavorato in modo simile (hashmap e hashgrep, anche se tecnicamente abbiamo solo loro liste, anche di dimensioni Fed). Per esempio: 

# Look for all the servers, and return them in a pipe-separated string
# (because we want this for some lame reason or another)
return join '|', 
       sort
       hashmap {$a =~ /^server_/ ? $b : +()} 
       %configuration_hash;

Vedi anche Higher Order Perl , http://hop.perl.plover.com -. buon uso di metaprogrammazione può rendere definizione dei compiti più coerente e leggibile, se è possibile mantenere la metaprogrammazione se stesso da ottenere nel modo

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top