Ce qui rend le code Perl maintenable?

Question

J'ai écrit Perl depuis plusieurs années et il est ma langue préférée pour le traitement de texte (un grand nombre des problèmes de la génétique / génomique je travaille sont facilement réduits à des problèmes de traitement de texte). Perl comme langue peut être très indulgent, et il est possible d'écrire très pauvre, mais fonctionnel, le code en Perl. L'autre jour, mon ami a dit qu'il appelle Perl écriture seule langue:. Écrire une fois, le comprendre une fois, et jamais essayer de revenir et de le corriger après est fini

Alors que j'ai vraiment été coupable d'écrire des scripts mauvais moments, je me sens comme je l'ai aussi écrit un code très clair et maintenable en Perl. Cependant, si quelqu'un m'a demandé ce que fait le code clair et maintenable, je ne serais pas en mesure de donner une réponse confiante.

Qu'est-ce que fait le code Perl maintenable? Ou peut-être une meilleure question est ce qui rend le code Perl difficile à maintenir? Supposons que je ne suis pas le seul qui maintiendra le code, et que les autres contributeurs, comme moi, ne sont pas des programmeurs professionnels Perl, mais les scientifiques ayant une expérience de la programmation.

Answer 1

Qu'est-ce que fait le code Perl ingérable? peu près tout ce qui fait tout autre programme ingérable. En supposant autre chose qu'un court script destiné à exécuter une tâche bien définie, ce sont:

• Les variables globales
• Manque de séparation des préoccupations: scripts Monolithiques
• PAS utiliser des identificateurs d'auto-documentation (noms de variables et les noms de méthode). Par exemple. vous devez savoir ce que le but d'une variable est de son nom. mauvais $c. $count mieux. bon $token_count.
  • Sort identifiants out. la taille du programme ne sont plus une préoccupation primordiale.
  • sous-programme A ou méthode appelée doWork ne dit rien
  • Faites facile de trouver la source de symboles d'un autre paquet. Soit utiliser le préfixe de package explicite ou importer explicitement chaque symbole utilisé par use MyModule qw(list of imports).
• spécifique Perl:
  • dépendance excessive sur les raccourcis et les variables de BUILTIN obscures
  • Abus de sous-programme prototypes
  • ne pas utiliser strict et ne pas utiliser warnings
• Réinventer la roue plutôt que d'utiliser les bibliothèques établies
• Ne pas utiliser un style d'indentation cohérente
• Ne pas utiliser l'espace blanc horizontal et vertical pour guider le lecteur

etc etc etc.

En fait, si vous pensez que Perl est -f>@+?*<.-&'_:$#/%! , et vous aspirez à des trucs d'écriture comme dans le code de production, alors, oui, vous aurez des problèmes.

Les gens ont tendance à confondre les programmeurs Perl trucs faire pour le plaisir (par exemple, JAPHs, golf, etc.) avec ce que de bons programmes Perl sont censés ressembler.

Je suis pas encore clair sur la façon dont ils sont capables de séparer dans leur esprit code IOCCC de maintenable C.

Answer 2

Je suggère:

1. Ne soyez pas trop intelligent avec le Perl. Si vous commencez à jouer au golf avec le code, il va rendre le code plus difficile à lire. Le code que vous écrivez doit être lisible et clair plus que nécessaire d'être intelligent.
2. Document du code. Si c'est un module, ajoutez POD décrivant l'utilisation typique et méthodes. Si c'est un programme, ajoutez POD pour décrire les options de ligne de commande et l'utilisation typique. S'il y a un algorithme velu, le document et fournir des références (URL) si possible.
3. Utilisez le formulaire /.../x des expressions régulières, et les documents. Pas tout le monde comprend bien les expressions rationnelles.
4. Savoir ce couplage est, et les avantages / inconvénients de couplage haut / bas.
5. Savoir ce que la cohésion est, et les avantages / inconvénients de la cohésion haut / bas.
6. utiliser des modules de manière appropriée. Un joli concept, bien contenu bien défini fait un grand module. La réutilisation de ces modules est le but. Ne pas utiliser des modules simplement pour réduire la taille d'un programme monolithique.
7. Tests unitaires écriture pour code. Une suite de test de bonne volonté non seulement vous permettre de prouver que votre code fonctionne aujourd'hui, mais aussi demain. Il vous permettra également de faire des changements plus audacieux dans l'avenir, avec confiance que vous n'êtes pas enfreindre les anciennes applications. Si vous faites des choses pause, puis, eh bien, vos tests suite n'était pas assez large.

Mais dans l'ensemble, le fait que vous vous souciez assez au sujet maintenabilité poser une question à ce sujet, me dit que vous êtes déjà dans un bon endroit et de penser le droit chemin.

Answer 3

Je n'utilise pas tous Perl Best Practices , mais c'est la chose qui Damian a écrit pour. Si oui ou non j'utiliser toutes les suggestions, ils sont tous vaut au moins considérer.

Answer 4

  

Qu'est-ce que fait le code Perl maintenable?

Au moins:

use strict;
use warnings;

Voir perldoc perlstyle quelques directives générales qui rendront vos programmes plus faciles à lire, à comprendre, et maintenir.

Answer 5

Un facteur très important pour la lisibilité du code que je ne l'ai pas vu mentionné dans d'autres réponses est l'importance de l'espace blanc, qui est à la fois Perl-agnostique et à certains égards Perl spécifiques.

Perl vous permet d'écrire du code très concis, mais des morceaux de Consise ne signifie pas qu'ils doivent être tous tassent.

L'espace blanc a beaucoup de sens / utilisations lorsque nous parlons de lisibilité, pas tous largement utilisés, mais le plus utile:

• Les espaces autour des jetons pour faciliter les séparer visuellement.

  Cet espace est d'autant plus important en Perl en raison de la prévalence des caractères de bruit de ligne, même dans le meilleur style du code Perl.

  Je trouve $myHashRef->{$keys1[$i]}{$keys3{$k}} être moins lisible à 2h du matin au milieu d'urgence producion par rapport à espacés: $myHashRef->{ $keys1[$i] }->{ $keys3{$k} }.

  Comme une note de côté, si vous trouvez votre code faisant beaucoup d'expressions de référence imbriquées profondes tout en commençant par la même racine, vous devez absolument envisager d'attribuer cette racine dans un pointeur temporaire (voir le commentaire / réponse de Sinan).

  Un cas particulier partiel, mais très important est d'expressions régulières cours. La différence a été illustré à mort dans tous les principaux matériaux dont je me souviens (PBP, RegEx livre O'Reilly, etc ..) donc je ne vais pas prolonger ce poste encore moins que les demandes de quelqu'un d'exemples dans les commentaires.

• indentation correcte et uniforme. D'oh. Évidemment. Pourtant, je vois trop beaucoup de code 100% en raison illisible à l'indentation merdique, et encore moins lisible lorsque la moitié du code a été en retrait avec TABs par une personne dont l'éditeur utilisé 4 onglets de caractères et une autre par une personne dont le rédacteur utilisé 8 caractères TABs. Il suffit de définir votre éditeur de sang pour faire doux (par exemple l'espace émulé) OET et ne font pas d'autres malheureux.

• Les lignes vides autour des unités séparées logiquement de code (les deux blocs et ensembles de lignes seulement). Vous pouvez écrire un programme Java 10000 ligne en 1000 lignes de bonne Perl. Maintenant, ne se sentent pas comme Benedict Arnold si vous ajoutez 100-200 lignes vides à ces 1000 pour rendre les choses plus lisibles.

• Fractionnement expressions uber long en plusieurs lignes, suivi de près par ...

• Corriger alignement vertical. Témoin la différence entre:

  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) {
  

  et

  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) {
  

  et

  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) {
  

  Personnellement, je préfère fixer l'alignement vertical une étape par alignement LHS et RHS (ce qui est particulièrement lisible en cas de longues requêtes SQL, mais aussi dans le code Perl lui-même, les deux longs conditionals comme celui-ci, ainsi que de nombreuses lignes des affectations et des initialisations hachage / matrice):

  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  ) {
  

  Comme une note de côté, dans certains cas, le code pourrait être encore plus lisible / maintenable de ne pas avoir de telles expressions longues en premier lieu. Par exemple. si le contenu du bloc de if(){} est un return, puis en faisant plusieurs déclarations de if/unless dont chacun a un bloc de retour peut être mieux.

Answer 6

Je vois cela comme une question de personnes étant dit que perl est illisible, et ils commencent à faire des hypothèses sur la maintability de leur propre code. si vous êtes assez consciencieux pour considérer la lisibilité comme marque de code de qualité, les chances sont cette critique ne vous concerne pas.

la plupart des gens citeront regexes quand ils discutent la lisibilité. regexes sont dsl embarqués en Perl et vous pouvez les lire ou non. si quelqu'un ne peut pas prendre le temps de comprendre quelque chose de si fondamental et essentiel à de nombreuses langues, je ne suis pas inquiet d'essayer de combler un certain déficit cognitif inférée ... ils devraient tout simplement l'homme, lisez-les perldocs et poser des questions si nécessaire .

d'autres citeront l'utilisation de Perl de court forme vars tels que @_ $! etc., ils sont facilement désambiguïsé ... Je ne suis pas intéressé à faire regarder comme perl java.

la hausse de toutes ces bizarreries et perlisms est que codebases écrites dans la langue sont souvent laconiques et compact. Je préfère lire dix lignes de perl d'une centaine de lignes de java.

pour moi, il y a tellement plus à « maintenabilité » que simplement avoir facile à lire le code. des tests d'écriture, les affirmations de marque ... font tout ce que vous pouvez faire pour appuyer sur perl et son écosystème de garder le code correct.

en bref:. Les programmes d'écriture pour être le premier correct, sécurisé, performant .... une fois que ces objectifs ont été atteints, alors souci de faire agréable de se pelotonner avec près d'un feu

Answer 7

Je dirais que les modèles d'emballage / objet, qui se réfléchit dans la structure des répertoires pour les fichiers .pm. Pour ma thèse, j'ai écrit beaucoup de code Perl que je réutiliser plus tard. Il était pour le générateur de schéma de LaTeX automatique.

Answer 8

Je vais parler des positifs choses à faire Perl maintenable.

Il est vrai que vous devriez généralement pas trop intelligent avec des déclarations très denses à la de return !$@;#% et similaires, mais une bonne quantité d'intelligent en utilisant des opérateurs de traitement de liste, comme map et grep et retourne la liste au contexte des goûts de split et opérateurs similaires, afin de le code d'écriture dans un style fonctionnel peut apporter une contribution positive à la maintenabilité. À mon dernier employeur nous avions aussi des fonctions de hachage manipulation snazzy qui ont travaillé d'une manière similaire (hashmap et hashgrep, bien que techniquement nous les avons nourris que des listes même taille). Par exemple:

# 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;

Voir aussi d'ordre supérieur Perl , http://hop.perl.plover.com -. bon usage de métaprogrammation peut faire définir des tâches plus cohérente et lisible, si vous pouvez garder le metaprogramming lui-même de prendre le chemin