Quelle était la règle standard de codage la plus étrange que vous ayez été obligé de suivre? [fermé]

Quand j'ai posé cette question, j'ai presque toujours obtenu un oui définitif, vous devriez avoir des normes de codage.

Quelle a été la règle standard de codage la plus étrange que vous ayez jamais été obligée de suivre?

Et par plus étrange, je veux dire le plus drôle, ou le pire, ou tout simplement bizarre.

Dans chaque réponse, veuillez mentionner la langue, la taille de votre équipe et les effets néfastes que cela a causés à vous et à votre équipe.

Je déteste quand l'utilisation de retours multiples est interdite.

indentation inversée. Par exemple:

    for(int i = 0; i < 10; i++)
        {
myFunc();
        }

et:

    if(something)
        {
// do A
        }
    else
        {
// do B
    }

Peut-être pas le plus bizarre que vous obtiendrez, mais je déteste vraiment vraiment quand je dois faire précéder les noms de table de base de données avec 'tbl'

Presque tous les types de notation hongroise.

Le problème avec la notation hongroise est qu'elle est très souvent mal comprise. L'idée originale était de préfixer la variable pour que le sens soit clair. Par exemple:

int appCount = 0; // Number of apples.
int pearCount = 0; // Number of pears.

Mais la plupart des gens l'utilisent pour déterminer le type.

int iAppleCount = 0; // Number of apples.
int iPearCount = 0;  // Number of pears.

C'est déroutant, car bien que les deux nombres soient des entiers, tout le monde le sait, vous ne pouvez pas comparer des pommes avec des poires.

Aucun opérateur ternaire autorisé là où je travaille actuellement:

int value = (a < b) ? a : b;

... parce que tout le monde "ne comprend pas". Si vous me disiez: "Ne l'utilisez pas parce que nous avons dû les réécrire quand les structures deviennent trop compliquées" (opérateurs ternaires imbriqués, n'importe qui?), Alors je comprendrais. Mais quand vous me dites que certains développeurs ne les comprennent pas ... euh ... Bien sûr.

Ne JAMAIS supprimer de code lors de modifications. On nous a dit de commenter tous les changements. Gardez à l'esprit que nous utilisons le contrôle de code source. Cette politique n'a pas duré longtemps car les développeurs étaient dans un tollé à ce sujet et comment cela rendrait le code illisible.

J'ai déjà travaillé sous la tyrannie du Mighty VB King .

Le VB King était le maître pur de MS Excel et VBA, ainsi que des bases de données (d' où son nom de famille: il a joué avec Excel pendant que les développeurs travaillaient avec des compilateurs, et le défier sur des bases de données pouvait avoir des effets néfastes sur votre carrière ... ).

Bien sûr, ses immenses compétences lui ont donné une vision unique des problèmes de développement et des solutions de gestion de projet: bien que n'étant pas exactement des normes de codage au sens strict, le VB King avait régulièrement de nouvelles idées sur les «normes de codage» et les «meilleures pratiques» qu'il essayait (et souvent réussi) à nous imposer. Par exemple:

• Tous les tableaux C / C ++ doivent commencer à l'index 1, au lieu de 0. En effet, l'utilisation de 0 comme premier index d'un tableau est obsolète et a été remplacée par la gestion perspicace des index de tableau de Visual Basic 6.

• Toutes les fonctions renverront un code d'erreur: il n'y a pas d'exceptions dans VB6, alors pourquoi en aurions-nous besoin? ( ie en C ++ )

• Comme "Toutes les fonctions doivent renvoyer un code d'erreur" n'est pas pratique pour les fonctions renvoyant des types significatifs, toutes les fonctions doivent avoir un code d'erreur comme premier paramètre [entrant / sortant].

• Tout notre code vérifiera les codes d'erreur ( cela a conduit au pire cas de VBScript if-indentation que j'ai jamais vu dans ma carrière ... Bien sûr, comme les clauses "else" n'ont jamais été gérées, aucune erreur n'a été trouvée jusqu'à trop tard ).

• Puisque nous travaillons avec C ++ / COM, à partir de ce jour, nous coderons toutes nos fonctions utilitaires DOM dans Visual Basic.

• Les erreurs ASP 115 sont mauvaises. Pour cette raison, nous utiliserons On Error Resume Next dans notre code VBScript / ASP pour les éviter.

• XSL-T est un langage orienté objet. Utilisez l'héritage pour résoudre vos problèmes (une stupide surprise m'a presque ouvert la mâchoire ce jour-là ).

• Les exceptions ne sont pas utilisées et doivent donc être supprimées. Pour cette raison, nous décocherons la case à cocher demandant l'appel du destructeur en cas de déroulement d'exception ( il a fallu des jours à un expert pour trouver la cause de toutes ces fuites de mémoire, et il a failli devenir fou quand il a découvert qu'ils avaient volontairement ignoré (et hidden) sa note technique sur la vérification de l'option à nouveau, envoyée quelques semaines avant ).

• attrapez toutes les exceptions dans l'interface COM de nos modules COM, et supprimez-les silencieusement (de cette façon, au lieu de planter, un module apparaîtrait seulement plus rapide ... Brillant! ... Comme nous avons utilisé la gestion des erreurs über décrite ci-dessus, il nous a même fallu un certain temps pour comprendre ce qui se passait vraiment ... Vous ne pouvez pas avoir à la fois de la vitesse et des résultats corrects, n'est-ce pas? ).

• À partir d'aujourd'hui, notre base de code sera divisée en quatre branches. Nous gérerons leur synchronisation et intégrerons toutes les corrections / évolutions de bogues à la main.

Tous sauf les tableaux C / C ++ , les fonctions utilitaires VB DOM et XSL-T comme langage POO ont été implémentés malgré nos protestations. Bien sûr, au fil du temps, certains ont été découverts, ahem , brisés et complètement abandonnés.

Bien sûr, la crédibilité de VB King n'a jamais souffert pour cela: parmi les cadres supérieurs, il est resté un expert technique "top gun" ...

Cela a produit des effets secondaires amusants, comme vous pouvez le voir en suivant le lien Quel est le meilleur commentaire dans le code source que vous ayez jamais rencontré?

Dans les années 80/90, j'ai travaillé pour une société de simulateurs d'avion qui utilisait FORTRAN. Notre compilateur FORTRAN avait une limite de 8 caractères pour les noms de variables. Les normes de codage de la société réservaient les trois premiers d'entre eux aux informations de style en notation hongroise. Nous avons donc dû essayer de créer des noms de variables significatifs avec seulement 5 caractères!

J'ai travaillé dans un endroit qui avait une fusion entre 2 entreprises. Le «dominant» avait un serveur majeur écrit en K&R C (c'est-à-dire pré-ANSI). Ils ont forcé les équipes Java (des deux bureaux - probablement 20 développeurs au total) à utiliser ce format, qui a joyeusement ignoré les 2 piliers du «débat d'accolade» et devient carrément fou:

if ( x == y ) 
    {
    System.out.println("this is painful");
    x = 0;
    y++;
    }

Interdit:

while (true) {

Permis:

for (;;) {

un de mes amis - nous l'appellerons CodeMonkey - a obtenu son premier emploi à l'université [ il y a de nombreuses années] en développant en interne en COBOL. Son premier programme a été rejeté comme «non conforme à nos standards» car il utilisait ... [frissonner!] Instructions IF imbriquées

les normes de codage interdisaient l'utilisation d'instructions IF imbriquées

maintenant, CodeMonkey n'était pas timide et était certain de ses capacités, alors il a persisté à demander à tout le monde en haut de la chaîne et dans l'allée pourquoi cette règle existait. La plupart ont prétendu ne pas savoir, certains inventaient des trucs sur la «lisibilité», et finalement une personne s'est souvenue de la raison originale: la première version du compilateur COBOL qu'ils utilisaient avait un bogue et ne gérait pas correctement les instructions IF imbriquées.

Ce bogue du compilateur, bien sûr, avait été corrigé pendant au moins une décennie, mais personne n'avait contesté les normes . [baaa!]

CodeMonkey a réussi à faire changer les normes - finalement!

Une fois travaillé sur un projet où les soulignements étaient interdits. Et je veux dire totalement interdit. Donc, dans l'application ac # winforms, chaque fois que nous ajoutions un nouveau gestionnaire d'événements (par exemple pour un bouton), nous devions renommer le nom de la méthode par défaut de buttonName_Click () en autre chose, juste pour satisfaire l'ego du gars qui a écrit le codage normes. À ce jour, je ne sais pas ce qu'il avait contre l'humble soulignement

Conventions de dénomination de base de données totalement inutiles. Chaque nom de table doit commencer par un nombre. Les nombres indiquent quel type de données se trouve dans le tableau.

• 0: données utilisées partout
• 1: données utilisées par un certain module uniquement
• 2: table de recherche
• 3: calendrier, chat et courrier
• 4: journalisation

Cela rend difficile la recherche d'une table si vous ne connaissez que la première lettre de son nom. De plus, comme il s'agit d'une base de données mssql, nous devons partout entourer les noms de tables de crochets.

-- doesn't work
select * from 0examples;

-- does work
select * from [0examples];

Nous faisions un projet C ++ et le chef d'équipe était un type Pascal.

Nous avions donc un fichier d'inclusion standard de codage pour redéfinir toute cette syntaxe embêtante C et C ++:

#define BEGIN {
#define END }

mais attendez il y a plus!

#define ENDIF }
#define CASE switch

etc. Il est difficile de se souvenir après tout ce temps.

Cela a pris ce qui aurait été du code C ++ parfaitement lisible et l'a rendu illisible par quiconque sauf le chef d'équipe.

Nous avons également dû utiliser la notation hongroise inversée, c'est-à-dire

MyClass *class_pt  // pt = pointer to type

UINT32 maxHops_u   // u = uint32

bien que bizarrement, j'aimais ça.

À un ancien emploi:

• Les tables "normales" commencent par T_
• Les tables "système" (généralement les recherches) commencent par TS_ (sauf quand elles ne le font pas parce que quelqu'un n'en a pas envie ce jour-là)
• Les tables de références croisées commencent par TSX_
• Tous les noms de champ commencent par F_

Oui c'est vrai. Tous les champs, dans chaque table. Pour que nous puissions dire que c'est un champ.

Un de mes amis a rencontré cette règle alors qu'il travaillait à un emploi au gouvernement. L'utilisation de ++ (pré ou post) a été totalement interdite. La raison: différents compilateurs peuvent l'interpréter différemment.

La moitié de l'équipe était en faveur de l'indentation à quatre espaces; l'autre moitié était en faveur de l'indentation à deux espaces.

Comme vous pouvez le deviner, la norme de codage en prescrivait trois, de manière à «offenser tous également» (une citation directe).

Ne pas pouvoir utiliser Reflection car le manager affirmait que cela impliquait trop de «magie».

Le plus étrange que j'ai eu, et celui qui m'a pris un certain temps à renverser, a été lorsque le propriétaire de notre entreprise a exigé que notre nouveau produit soit IE uniquement. Si cela pouvait fonctionner sur FireFox, ce n'était pas grave, mais cela devait être IE uniquement.

Cela peut ne pas sembler trop étrange, à l'exception d'un petit défaut. Tous les logiciels étaient destinés à un progiciel de serveur sur mesure, fonctionnant sous Linux, et toutes les boîtes client que notre client achetait étaient Linux. À moins d'essayer de comprendre comment faire fonctionner Wine (à l'époque, très peu fiable) sur toutes ces boîtes et de voir si nous pouvions faire fonctionner IE et former leurs administrateurs à déboguer les problèmes de Wine, ce n'était tout simplement pas possible. pour répondre à la demande du propriétaire. Le problème était qu'il faisait la conception Web et ne savait tout simplement pas comment rendre les sites Web compatibles avec FireFox.

Cela ne vous choquera probablement pas de savoir que notre entreprise a fait faillite.

Utilisation de noms d'identificateurs génériques numérotés

Dans mon travail actuel, nous avons deux règles qui sont vraiment méchantes:

Règle 1: Chaque fois que nous créons un nouveau champ dans une table de base de données, nous devons ajouter des champs de réserve supplémentaires pour une utilisation future. Ces champs de réserve sont numérotés (car personne ne sait quelles données ils contiendront un jour). La prochaine fois que nous aurons besoin d'un nouveau champ, nous cherchons d'abord un champ de réserve inutilisé.

On finit donc par customer.reserve_field_14contenir l'adresse e-mail du client.

Un jour, notre patron a pensé à introduire des tables de réserve , mais heureusement nous avons pu le convaincre de ne pas le faire.

Règle 2: L'un de nos produits est écrit en VB6 et VB6 a une limite du nombre total de noms d'identifiants différents et comme le code est très grand, nous nous heurtons constamment à cette limite. En guise de «solution», tous les noms de variables locales sont numérotés:

• Lvarlong1
• Lvarlong2
• Lvarstr1
• ...

Bien que cela contourne efficacement la limite d'identifiant, ces deux règles combinées conduisent à un beau code comme celui-ci:

...

If Lvarbool1 Then
  Lvarbool2 = True
End If

If Lvarbool2 Or Lvarstr1 <> Lvarstr5 Then
  db.Execute("DELETE FROM customer WHERE " _ 
      & "reserve_field_12 = '" & Lvarstr1 & "'")
End If

...

Vous pouvez imaginer à quel point il est difficile de corriger l'ancien code ou celui de quelqu'un d'autre ...

Dernière mise à jour: Nous utilisons désormais également des «procédures de réservation» pour les membres privés:

Private Sub LSub1(Lvarlong1 As Long, Lvarstr1 As String)
  If Lvarlong1 >= 0 Then 
    Lvarbool1 = LFunc1(Lvarstr1)
  Else
    Lvarbool1 = LFunc6()
  End If
  If Lvarbool1 Then
    LSub4 Lvarstr1
  End If
End Sub

EDIT: Il semble que ce modèle de code devient de plus en plus populaire. Voir ce post The Daily WTF pour en savoir plus: Astigmatisme :)

À l'époque de C ++, nous n'étions pas autorisés à utiliser ==,> =, <=, &&, etc., il y avait des macros pour cela ...

if (bob EQ 7 AND alice LEQ 10)
{
   // blah
}

c'était évidemment pour traiter la "vieille affectation accidentelle dans le bogue conditionnel", cependant nous avions aussi la règle "mettre les constantes avant les variables", donc

if (NULL EQ ptr); //ok
if (ptr EQ NULL); //not ok

Je viens de me souvenir que la norme de codage la plus simple que j'aie jamais entendue était "Écrivez du code comme si le prochain responsable était un psychopathe vicieux qui sait où vous vivez."

Notation hongroise en général.

J'ai eu beaucoup de règles stupides , mais pas beaucoup que je considère carrément étranges.

Le plus idiot était un travail à la NASA que j'avais travaillé au début des années 90. C'était un travail énorme, avec plus de 100 développeurs. Les développeurs expérimentés qui ont rédigé les normes de codage ont décidé que chaque fichier source devait commencer par un acronyme de quatre lettres et que la première lettre devait représenter le groupe responsable du fichier. C'était probablement une excellente idée pour les anciens projets FORTRAN 77 auxquels ils étaient habitués.

Cependant, c'était un projet Ada , avec une belle structure de bibliothèque hiérarchique, donc cela n'avait aucun sens. Chaque répertoire était plein de fichiers commençant par la même lettre, suivis de 3 autres lettres absurdes, d'un trait de soulignement, puis d'une partie du nom de fichier qui comptait. Tous les paquets Ada devaient commencer par cette même verrue à cinq caractères. Les clauses Ada "use" n'étaient pas autorisées non plus (sans doute une bonne chose dans des circonstances normales), donc cela signifiait que toute référence à un identifiant qui n'était pas local à ce fichier source devait également inclure cette verrue inutile. Il aurait probablement dû y avoir une insurrection à ce sujet, mais l'ensemble du projet était géré par des programmeurs juniors et fraîchement recrutés par les étudiants (moi-même étant ce dernier).

Une déclaration d'affectation typique (déjà verbeuse dans Ada) finirait par ressembler à ceci:

NABC_The_Package_Name.X := NABC_The_Package_Name.X + 
  CXYZ_Some_Other_Package_Name.Delta_X;

Heureusement, ils étaient au moins suffisamment éclairés pour nous permettre plus de 80 colonnes! Pourtant, la verrue de l'installation était suffisamment détestée pour qu'elle devienne un code standard au sommet des fichiers source de tout le monde pour utiliser les «renommés» d'Ada pour se débarrasser de la verrue. Il y aurait un changement de nom pour chaque package importé ("withed"). Comme ça:

package Package_Name renames NABC_Package_Name;
package Some_Other_Package_Name renames CXYZ_Some_Other_Package_Name;
--// Repeated in this vein for an average of 10 lines or so

Ce que le plus créatif parmi nous a fait, c'est d'essayer d' utiliser la verrue pour créer un nom de paquet réellement sensé (ou idiot). (Je sais ce que vous pensez, mais les explications n'étaient pas autorisées et honte à vous! C'est dégoûtant). Par exemple, je suis dans le C COMMUN groupe de code, et je devais faire un paquet à l' interface avec le W groupe orkstation. Après une séance de brainstorming avec le gars de Workstation, nous avons décidé de nommer nos paquets afin que quelqu'un ayant besoin des deux écrive:

with CANT_Interface_Package;
with WONT_Interface_Package;

Quand j'ai commencé à travailler à un endroit et à entrer mon code dans le contrôle de code source, mon patron est soudainement venu vers moi et m'a demandé d'arrêter de commettre autant de choses. Il m'a dit qu'il était déconseillé de faire plus d'un commit par jour pour un développeur car cela gâche le contrôle de code source. Je l'ai simplement bouche bée ...

Plus tard, j'ai compris que la raison pour laquelle il est même venu me voir à ce sujet est que le serveur SVN lui enverrait (ainsi qu'à 10 autres hauts dirigeants) un mail pour chaque commit que quelqu'un fait. Et en jonçant le contrôle de la source, j'ai deviné qu'il avait sa boîte aux lettres.

Faire toutes les requêtes de base de données via des procédures stockées dans Sql Server 2000. Des requêtes complexes multi-tables aux requêtes simples comme:

select id, name from people

Les arguments en faveur des procédures étaient:

• Performance
• Sécurité
• Maintenabilité

Je sais que le sujet de la procédure est assez controversé, alors n'hésitez pas à noter ma réponse par la négative;)

Il doit y avoir 165 tests unitaires (pas nécessairement automatisés) pour 1000 lignes de code. Cela fonctionne à un test pour environ toutes les 8 lignes.

Inutile de dire que certaines des lignes de code sont assez longues et que les fonctions renvoient ces pointeurs pour permettre le chaînage.

Nous avons dû trier toutes les fonctions par classes par ordre alphabétique, pour les rendre "plus faciles à trouver". Qu'à cela ne tienne, l'ide avait une baisse. C'était trop de clics.

(le même responsable technique a écrit une application pour supprimer tous les commentaires de notre code source).

En 1987 environ, j'ai pris un emploi dans une entreprise qui m'a embauché parce que je faisais partie d'une petite poignée de personnes qui savaient comment utiliser Revelation. La révélation, si vous n'en avez jamais entendu parler, était essentiellement une implémentation sur PC du système d'exploitation Pick - qui, si vous n'en avez jamais entendu parler, tire son nom de son inventeur, le fabuleusement nommé Dick Pick. On peut en dire beaucoup sur Pick OS, la plupart du temps bien. Un certain nombre de fournisseurs de supermini (Prime et MIPS, au moins) ont utilisé Pick, ou leurs propres implémentations personnalisées.

Cette société était une boutique de premier ordre et pour ses systèmes internes, elle utilisait Information. (Non, c'était vraiment son nom: c'était l'implémentation de Pick par Prime.) Ils avaient un contrat avec l'État pour construire un système basé sur PC, et avaient consacré environ un an à leur projet Revelation avant que le gars ne fasse tout le travail, qui était aussi leur directeur MIS, a décidé qu'il ne pouvait plus faire les deux emplois et m'a embauché.

En tout cas, il avait établi un certain nombre de normes de codage pour leur logiciel basé sur Prime, dont beaucoup dérivaient de deux conditions de base: 1) l'utilisation de terminaux stupides à 80 colonnes, et 2) le fait que depuis Prime ne l'a pas fait. t avoir un éditeur visuel, il avait écrit le sien. En raison de la portabilité magique du code Pick, il avait introduit son éditeur dans Revelation, et avait construit l'ensemble du projet sur le PC en l'utilisant.

Revelation, bien sûr, étant basé sur PC, avait un très bon éditeur plein écran, et n'a pas objecté lorsque vous avez dépassé la colonne 80. Cependant, pendant les premiers mois que j'y étais, il a insisté pour que j'utilise son éditeur et ses normes.

Ainsi, la première norme était que chaque ligne de code devait être commentée. Chaque ligne. Aucune exception. Son raisonnement était que même si votre commentaire disait exactement ce que vous veniez d'écrire dans le code, devoir le commenter signifiait au moins avoir pensé à la ligne deux fois. De plus, comme il le soulignait joyeusement, il avait ajouté une commande à l'éditeur qui formatait chaque ligne de code afin que vous puissiez mettre un commentaire de fin de ligne.

Oh oui. Lorsque vous avez commenté chaque ligne de code, c'était avec des commentaires de fin de ligne . En bref, les 64 premiers caractères de chaque ligne étaient pour le code, puis il y avait un point-virgule, et ensuite vous aviez 15 caractères pour décrire ce que faisaient vos 64 caractères. En bref, nous utilisions une convention de langage assembleur pour formater notre code Pick / Basic. Cela a conduit à des choses qui ressemblaient à ceci:

EVENT.LIST[DATE.INDEX][-1] = _         ;ADD THE MOST RECENT EVENT
   EVENTS[LEN(EVENTS)]                 ;TO THE END OF EVENT LIST

(En fait, après 20 ans, j'ai finalement oublié la syntaxe de continuation de ligne de R / Basic, donc cela peut avoir l'air différent. Mais vous voyez l'idée.)

De plus, chaque fois que vous deviez insérer des commentaires multilignes, la règle était d'utiliser une boîte à fleurs:

************************************************************************
**  IN CASE YOU NEVER HEARD OF ONE, OR COULDN'T GUESS FROM ITS NAME,  **
**  THIS IS A FLOWER BOX.                                             **
************************************************************************

Oui, ces astérisques fermants sur chaque ligne étaient obligatoires. Après tout, si vous utilisiez son éditeur, ce n'était qu'une simple commande d'éditeur pour insérer une boîte à fleurs.

Le faire céder et me laisser utiliser l'éditeur intégré d'Apocalypse a été une véritable bataille. Au début, il a insisté, simplement parce que c'était les règles. Quand j'ai objecté que a) je connaissais déjà l'éditeur d'Apocalypse b) il était nettement plus fonctionnel que son éditeur, c) d'autres développeurs d'Apocalypse auraient la même perspective, il a rétorqué que si je ne m'entraînais pas sur son éditeur, je ne le ferais pas jamais être en mesure de travailler sur la base de code Prime, ce qui, comme nous le savions tous les deux, n'allait pas se produire tant que l'enfer ne serait pas gelé. Finalement, il a cédé.

Mais les normes de codage ont été les dernières à disparaître. Les commentaires de la boîte à fleurs en particulier étaient une stupide perte de temps, et il m'a combattu bec et ongles dessus, disant que si j'utilisais juste le bon éditeur, les maintenir serait parfaitement facile. (Le tout est devenu assez passif-agressif.) Finalement, j'ai cédé tranquillement, et à partir de là, tout le code que j'ai apporté aux revues de code a eu ses précieux commentaires sur les boîtes à fleurs.

Un jour, plusieurs mois après le début de mon travail, alors que je me suis avéré plus que compétent (surtout en comparaison avec le remarquable défilé d'autres codeurs qui sont passés par ce bureau pendant que j'y travaillais), il regardait par-dessus mon épaule alors que je a fonctionné, et il a remarqué que je n'utilisais pas de commentaires de boîtes à fleurs. Oh, j'ai dit, j'ai écrit un formateur de code source qui convertit mes commentaires dans votre style lorsque je les imprime. C'est plus facile que de les maintenir dans l'éditeur. Il ouvrit la bouche, réfléchit un instant, la referma, s'en alla et nous ne parlâmes plus jamais des normes de codage. Nos deux tâches sont devenues plus faciles par la suite.

Lors de mon premier emploi, tous les programmes C, aussi simples ou complexes soient-ils, n'avaient que quatre fonctions. Vous aviez le principal, qui appelait tour à tour les trois autres fonctions. Je ne me souviens plus de leurs noms, mais ils étaient quelque chose du genre begin (), middle () et end (). begin () a ouvert les fichiers et les connexions à la base de données, end () les a fermés et middle () a fait tout le reste . Inutile de dire que middle () était une fonction très longue.

Et pour rendre les choses encore meilleures, toutes les variables devaient être globales.

L'un de mes souvenirs les plus fiers de ce travail est d'avoir participé à la révolte générale qui a conduit à la destruction de ces normes.

Une norme de codage C écrite en externe qui avait la règle `` ne comptez pas sur la priorité des opérateurs intégrée, utilisez toujours des crochets ''

Assez juste, l'intention évidente était d'interdire:

a = 3 + 6 * 2;

en faveur de:

a = 3 + (6 * 2);

Le fait était que cela était appliqué par un outil qui suivait les règles de syntaxe C que «=», «==», «.» et l'accès au tableau sont des opérateurs. Donc, code comme:

a[i].x += b[i].y + d - 7;

devait être écrit comme suit:

((a[i]).x) += (((b[i]).y + d) - 7);