Faut-il encourager les styles de codage en faveur de l'autonomie du développeur, ou le décourager en faveur de la cohérence?

Un développeur écrit des if/elseblocs avec des instructions de code d'une ligne comme:

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

Un autre utilise des accolades pour chacun d'eux:

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

Un développeur instancie d'abord un objet, puis l'utilise:

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

Un autre développeur instancie et utilise l'objet sur une seule ligne:

new HelperClass().DoSomething();

Un développeur est plus simple avec les tableaux et les forboucles:

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

Un autre écrit:

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

Je suis sûr que vous savez de quoi je parle. Je l'appelle style de codage (parce que je ne sais pas comment ça s'appelle). Mais comme nous l'appelons, est-ce bon ou mauvais? L'encourager a-t-il pour effet une productivité plus élevée des développeurs? Devrions-nous demander aux développeurs d'essayer d'écrire du code comme nous le leur disons, afin de rendre l'ensemble du système cohérent avec le style?

Un document sur les normes de codage est utile. C'est plus utile quand il est assez court pour que tout le monde puisse se souvenir de tout sans trop de problèmes et quand cela ne cause trop de douleur à personne.

La façon dont vous choisissez d'indenter le code dans votre organisation, ou de mettre en majuscule les noms, ou d'implémenter vos boucles, ou de commenter votre code n'a pas beaucoup d'importance; la partie utile est d'amener tout le monde à écrire du code qui ressemble à peu près à tout le monde.

• Cela évite d'avoir à passer une minute à recalibrer vos attentes quant à l'emplacement des accolades et à chaque fois que vous regardez le code de quelqu'un d'autre.
• Cela évite d'avoir plusieurs styles de code différents dans le même fichier.
• Peut-être plus important encore, avoir une norme écrite évite les arguments sur les pratiques de codage lors des révisions de code.

Encore une fois, ce que sont les normes n'a pas autant d'importance que d'avoir une sorte de norme simple et directe. Alors, mettez tous vos développeurs dans une pièce et laissez-les discuter de ce que devraient être les normes. Cette réunion pourrait se poursuivre indéfiniment, les règles sont donc les suivantes:

• Tout ce qui n'est pas décidé à la fin de la réunion sera décidé par le directeur.
• La réunion se terminera après deux heures, ou lorsque quelqu'un commencera à crier ou à pleurer, selon la première éventualité.
• L'ensemble de la norme tiendra (dans une taille de caractères raisonnable!) Sur une ou deux feuilles de papier, recto verso uniquement si cela est absolument nécessaire.

Envisagez d'adopter quelqu'un | d'autre | normes soit comme point de départ pour votre propre réunion de normes de codage, soit comme un moyen d'éviter complètement la réunion.

Une fois convenus, les développeurs devraient être en mesure (et devraient être censés) se contrôler. Un écart occasionnel par rapport à la norme ne devrait pas être un gros problème (et pourrait même être justifié), mais le refus spontané d'abandonner un style personnel préféré en faveur de la norme devrait entraîner une réinstallation immédiate au bureau avec les conduites d'eau qui fuient, ou autre chose .

Demian Brecht pointe les outils à charpie. Ce sont un complément parfait à un document de normes de codage. Il est simplement bon de s'en tenir aux normes de style de codage ; il est important de s'en tenir aux normes de codage relatives aux pratiques dangereuses. Personne d'autre que l'auteur ne vérifiera que chaque ligne de code respecte la norme de style, mais vous devriez certainement envisager de créer un outil lint dans le flux de travail de votre équipe pour détecter automatiquement les bogues potentiels. De plus, l'outil lui-même peut codifier les pratiques acceptées afin que vous n'ayez pas à les répertorier toutes individuellement dans les normes de codage; spécifiez simplement la configuration de l'outil.

Remarque: L'idée de «normes de codage» n'est pas unique à la programmation. Les «normes de codage» sont utilisées dans de nombreux domaines, parfois au sein d'une organisation, plus souvent dans l'ensemble d'une industrie ou d'une profession. Quelques exemples:

• Les documents juridiques tels que les dossiers judiciaires et les transcriptions respectent des formats spécifiques.
• Les scripts et les scénarios doivent être écrits dans un style particulier afin d'être pris au sérieux.
• Les dessins techniques doivent souvent avoir un cartouche sous forme standard.
• Les formats de bibilographie sont standardisés.

Dans chaque cas (et dans bien d'autres), un praticien compétent pourrait facilement comprendre un "code" qui ne répond pas à la norme attendue. Pourquoi tant d'industries persistent-elles à rédiger des exigences détaillées pour les documents qui n'ont même pas besoin d'être analysés par un compilateur? Parce que le style compte . La présentation des informations dans un style standard permet au lecteur de se concentrer entièrement sur le contenu, accélère la lecture et facilite la compréhension, et réduit les erreurs.

Le style n'a pas d'importance.

Là, je l'ai dit.

Après 30 ans, et des centaines de sites clients et du code (estimé) de 500 (ou plus) membres de l'équipe au cours de ces années, j'ai trouvé que le style n'avait pas d'importance.

Faites-le fonctionner d'abord.

Obtenez-le pour utiliser un volume optimal de ressources (c'est-à-dire, la bonne structure de données, le bon algorithme).

Agitez sur le «style» après que tout le reste a été résolu. Faire du "style" avec des outils, jamais manuellement.

Il existe des styles de codage et des odeurs de codage. Ce n'est pas une fois que j'ai trouvé:

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

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

Mon ancien employeur a rigoureusement interdit d'utiliser la multiligne if()sans appareil orthopédique. Il était considéré comme une faute de type "recommencez et vous êtes viré". Les constructions autorisées étaient

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

Cela résultait d'une erreur comme celle que j'ai montrée ci-dessus, qui a pris quelques heures pour trouver l'arrêt de la page principale du portail.

Il y a des choses que vous devez toujours faire. Comme 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:
     ...

Pendant ce temps, en tapant:

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

sans fermer un caseavec //fallthroughest considéré comme un bug.

Généralement, il y a la norme de codage qui est les directives qui peuvent être ignorées, interprétées de manière créative ou modifiées pour des besoins donnés. Et il y a la section sur les "odeurs" et elle doit être rigoureusement respectée.

Créez une cohérence avec une bonne conception initiale. Ce que vous décrivez dans la question n'est rien de moins que la micro-gestion. Je fais beaucoup de développement web. Je privilégie donc le développement RESTful et CRUD exposé en tant que services. Cela garantit des entités simples et bien définies qui peuvent être utilisées de différentes manières.

Cette conception me permet également de déléguer des détails d'implémentation à d'autres développeurs. De cette façon, ils remplissent les blancs plutôt que de créer une conception complète du système.

L'absence d'une conception globale crée des incohérences du système. La critique des itérations de base et des constructions en boucle n'améliore guère la conception du système. Ces types de problèmes sont mieux résolus avec une approche pratique, StyleCop.

Pouvez-vous dessiner un diagramme relativement simple de la conception globale de votre système? Une conception décrivant les éléments / entités impliqués dans un nouveau développeur d'équipe. Si vous ne le pouvez pas, ou si elle est très impliquée, la conception fait défaut.

À mon humble avis, cela dépend ...

Vos deux premiers exemples ne sont pas seulement une question de goût personnel pour moi.

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

(sans crochets) = plus sujet aux bogues, si plus de code est ajouté plus tard:

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

Et cela est moins pratique pour déboguer:

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

Vous ne pouvez pas simplement définir un point d'arrêt là où vous en avez besoin. Si c'est un cas unique - assez bien, mais nous en discutons comme une question de style, et une fois que vous avez des trucs comme ça partout, le débogage devient plus désagréable qu'il ne doit l'être.

Quant à votre troisième exemple (pour vs foreach), je le considère cependant comme une question de goût.

Ni. J'éviterais les règles de codage strictes pour éviter d'être fastidieux, pointilleux, microgestionnaire et le pire de tous les temps. Votre sentiment d'autonomie est votre propre problème. Si je veux que vous vous sentiez mieux dans votre peau, je vous achèterai un tour de votre boisson préférée. À part ça, faites quelque chose.

L'utilisation de conventions, de noms de variables, de noms de classe, etc. est une bonne pratique. Mais les styles de codage comme les exemples que vous fournissez sont plutôt triviaux et n'ont aucun effet sur la lisibilité ou l'efficacité du code. D'un autre côté, le surcoût lié à l'application d'un style donné combiné aux efforts des développeurs pour le suivre entraînera des problèmes.

Utilisez un outil de charpie standard (apparemment FxCop pour C #). Bien que ce ne soit pas la finalité, la cohérence est importante dans les grands projets qui ont un certain nombre de personnes qui y travaillent.

Si vous travaillez simplement sur votre propre projet ou une petite équipe, beaucoup diront que c'est exagéré. Je pense le contraire (j'utilise PEP8 pour Python, même dans mes projets personnels de développeur unique).

La plupart des exemples que vous avez donnés, cependant, ne seraient probablement pas pris par un outil de peluchage car ils n'ont tout simplement pas d'importance.

L'application d'un style de codage uniforme est toujours difficile. Idéalement, une telle tâche banale devrait être laissée à un outil à gérer. J'applaudis la communauté linguistique Go pour cela.

C'est un mélange des deux. Ce n'est pas parce qu'il s'agit d'une norme qu'il est lisible et maintenable. S'il n'y a pas encore de norme instillée, ou s'il y a des aspects défectueux et illisibles, une révision est appropriée.

En dernière analyse, c'est le programmeur qui pilote la programmation. Les problèmes de style existent, mais ils sont secondaires à la sortie du programme.

Il est utile de donner aux programmeurs QUELQUES conseils de style. Cela peut / devrait être fait avant que les programmeurs ne soient mis au travail, surtout s'ils sont des débutants relatifs à l'environnement ou à la programmation elle-même. Sous réserve de conseils, certains programmeurs seront très soucieux de leur style, d'autres moins. Les conseils donnés au début du projet aideront le premier groupe de programmeurs, facilitant ainsi la tâche globale. Cela pourrait ne pas faire grand-chose pour le deuxième groupe, qui (espérons-le) compensera en créativité ce qui manque de conformité.

Je pense que cela dépend de la taille du projet et du nombre de personnes qui y travaillent. Un programmeur qualifié peut regarder les deux styles de formats différents et savoir ce qui se passait dans les deux mais il doit y avoir une concordance pour que l'œil puisse l'attraper facilement. Si vous allez faire vos déclarations sur une seule ligne sans les accolades, ce projet ne devrait pas les utiliser. Celui qui dirige ce projet devrait avoir ce choix. J'aime que les choses soient claires et aussi très compactes car je peux les obtenir. Si vous allez faire une seule ligne si les statmeents ils ressemblent mieux à ceci

if() {}
else() {}

Ou même:

if() {} else () {}

Mais une seule ligne si ne doit pas utiliser l'espacement d'une mulitiline si. C'est comme ça que je fais les choses. Je me fiche de la façon dont l'objet est appelé et cela dépend du nombre de fois qu'il est appelé. si elle est appelée plusieurs fois, je démarre plutôt l'objet et dépend si elle a des constucteurs et ce qui ne l'est pas aussi. Parce que si vous avez un constructeur et que vous appelez:

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

Ensuite, vous avez fini par appeler deux fois la méthode du constructeur d'objet alors qu'elle aurait pu être évitée en instanciant complètement l'objet.

Quand il s'agit de foreach et de boucles C'est aussi à propos de la lanauge, certaines lanauges vous donnent un meilleur contrôle lorsque vous regardez le tableau dans une boucle foreach, vous avez donc la clé et la valeur dans les tableaux temporaires. Et je sais que certaines langues ont une sorte d'optimisation car elles peuvent regarder la boucle et savoir exactement combien de fois elle va être appelée.

Bien que votre premier exemple ne soit pas génial (l'argument selon lequel il est plus sujet aux bogues en cours de modification a un certain poids), en général, je préfère en fait que les développeurs utilisent des styles de codage légèrement différents.

Après avoir travaillé avec le code d'autres membres de l'équipe, parfois pendant aussi peu que quelques mois, il commence essentiellement à fonctionner en ligne et en ligne git blame. Après avoir été dans mon entreprise pendant plus de 10 ans, je peux probablement vous dire avec une précision de 80% + qui a écrit une classe donnée n'importe où dans nos 500k lignes de code, juste en la regardant.

Bien qu'il y ait un tout petit peu de "temps de rampe" lorsque vous commencez à regarder du code qui utilise un style avec lequel vous n'êtes pas d'accord, ce que vous faites vraiment à ce moment-là est de dire "oh, cela ressemble au code de John Doe (parce que il utilise le style X mais pas le style Y, etc.) ". Et cela apporte avec lui tout un tas de contexte. Pour une première approximation, vous savez à quoi vous attendre du code de John - quelles autres parties de la base de code il comprend bien et quelles parties il ne comprend pas, qu'il soit un gourou SQL ou un novice GUI, etc. etc.

L'exécution du code de tout le monde via un formateur supprime essentiellement ces informations, les cachant derrière un git blame, que vous ne pouvez pas prendre la peine d'exécuter.

Cela dépend vraiment beaucoup du type d'organisation.

Si vous êtes un petit groupe de super-héros, tout type de style convient. Si chacun a son propre style, et qu'il est à la fois bon et cohérent en interne, alors c'est tout le processus dont vous avez besoin. Les super-héros diront: "Jane a des crochets, c'est ce qu'elle veut dire" ou "Jack utilise camelCase pour les variables".

Les normes universelles sont généralement les meilleures pour faire de tout le monde un joueur B +. Vos super-héros seront abattus par cela. Mais si vous voulez qu'un joueur A et une demi-douzaine de joueurs B et une demi-douzaine de joueurs C atteignent la moyenne du B +, alors vous voulez des normes cohérentes. Dans ce cas, vous voulez que tout le monde fasse les mêmes choses afin que le joueur A puisse parcourir le code de chacun le plus rapidement possible.

Beaucoup d'entre vous disent: "Mais attendez, pourquoi ne pas éliminer les joueurs B et C?"

La réalité est qu'il n'y a pas beaucoup de super-héros. Bien qu'il soit payant de les trouver et de les entretenir chez Google, la mise en place d'un nouveau système de facturation pour Ma Bell peut être plus rentable avec cette dernière équipe. (Et si vous avez vraiment des super-héros, 4 ou 5 d'entre eux seront deux fois plus chers qu'une douzaine de juniors)