Quel est l'avantage de ne pas utiliser la notation hongroise?

Une des choses avec laquelle je me bats, n’utilise pas la notation hongroise. Je ne veux pas avoir à aller à la définition de variable juste pour voir de quel type il s'agit. Quand un projet prend de l'ampleur, il est agréable de pouvoir regarder une variable préfixée par 'bool' et de savoir qu'il recherche true / false au lieu de 0/1 .

Je fais aussi beaucoup de travail dans SQL Server. Je préfixe mes procédures stockées avec 'sp' et mes tables avec 'tbl', sans parler de toutes mes variables de la base de données, respectivement.

Je vois partout que personne ne veut vraiment utiliser la notation hongroise, au point de l’éviter. Ma question est la suivante: quel est l’avantage de ne pas utiliser la notation hongroise et pourquoi la majorité des développeurs l’évitent-elle comme la peste?

Parce que son intention initiale (voir http://www.joelonsoftware.com/articles/Wrong.html et http://fplanque.net/Blog/devblog/2005/05/11/hungarian_notation_on_steroids ) a été mal comprise et elle l’a été ( ab) utilisé pour aider les gens à se rappeler du type d’une variable lorsque la langue qu’elle utilise n’est pas typée de manière statique. Dans toutes les langues statiques, vous n'avez pas besoin du ballast de préfixes ajouté pour vous indiquer le type d'une variable. Dans de nombreux langages de script non typés, cela peut aider, mais il a souvent été abusé au point de devenir totalement maniable. Malheureusement, au lieu de revenir à l’intention initiale de la notation hongroise, les gens viennent d’en faire l’une de ces «choses perverses» que vous devriez éviter.

La notation hongroise était destinée à préfixer les variables avec une sémantique. Par exemple, si vous avez des coordonnées d'écran (à gauche, en haut, à droite, en bas), vous préfixeriez les variables avec des positions d'écran absolues avec " abs" et les variables avec des positions relatives à une fenêtre avec " rel". De cette façon, il serait évident pour tout lecteur de passer une coordonnée relative à une méthode nécessitant des positions absolues.

mise à jour (en réponse au commentaire de delnan)

IMHO la version abusée devrait être évitée comme la peste parce que:

• cela complique la dénomination. Lorsque (ab) utilise la notation hongroise, il y aura toujours des discussions sur la spécificité des préfixes. Par exemple: listboxXYZou MyParticularFlavourListBoxXYZ.
• cela rend les noms de variable plus longs sans aider à comprendre le rôle de la variable.
• Cela évite en quelque sorte l’objet de l’exercice lorsque, pour éviter les longs préfixes, ceux-ci sont abrégés en abréviations et vous avez besoin d’un dictionnaire pour savoir ce que chaque abréviation signifie. Est-ce uiqu'un entier non signé? une interface comptée non référencée? quelque chose à voir avec les interfaces utilisateur? Et ces choses peuvent être longues . J'ai vu des préfixes de plus de 15 caractères apparemment aléatoires qui sont supposés transmettre le type exact du var mais ne font que mystifier.
• ça devient vite obsolète. Lorsque vous modifiez invariablement le type d'une variable, les personnes (lol) oublient de mettre à jour le préfixe pour refléter le changement ou ne le mettent pas volontairement à jour car cela provoquerait des modifications de code partout où la variable est utilisée ...
• cela complique de parler de code parce que "@g". dit: Les noms de variables avec la notation hongroise sont généralement difficiles à prononcer soupe alphabet. Cela inhibe la lisibilité et la discussion sur le code, car vous ne pouvez pas dire les noms.
• ... beaucoup plus que je ne me souviens pas pour le moment. Peut-être parce que j'ai le plaisir de ne pas avoir à faire face à la notation hongroise abusée depuis longtemps ...

La notation hongroise est un anti-modèle de dénomination dans les environnements de programmation et les formes de tautologie modernes .

Il répète inutilement des informations sans bénéfice ni frais de maintenance supplémentaires. Que se passe-t-il lorsque vous changez intde type long, par exemple, vous devez maintenant rechercher et remplacer toute votre base de code pour renommer toutes les variables ou elles sont désormais sémantiquement fausses, ce qui est pire que si vous n'aviez pas dupliqué le type dans le nom.

Cela viole le principe DRY. Si vous devez préfixer vos tables de base de données avec une abréviation pour vous rappeler qu'il s'agit d'une table, vous ne devez absolument pas nommer vos tables de manière sémantique de manière descriptive. Même chose pour tout ce que vous faites avec cela. Il s’agit simplement de dactylographier en plus et de travailler sans but lucratif avec un environnement de développement moderne.

Wikipedia a une liste des avantages et inconvénients de la notation hongroise et peut donc probablement fournir la réponse la plus complète à cette question. Les opinions notables sont également une lecture assez intéressante.

L’avantage de ne pas utiliser la notation hongroise n’est fondamentalement qu’éviter ses inconvénients:

• La notation hongroise est redondante lorsque la vérification du type est effectuée par le compilateur. Les compilateurs de langues fournissant une vérification de type garantissent que l'utilisation d'une variable est automatiquement cohérente avec son type; les vérifications à vue sont redondantes et sujettes à des erreurs humaines.

• Tous les environnements de développement intégrés modernes affichent des types de variable à la demande et signalent automatiquement les opérations utilisant des types incompatibles, ce qui rend la notation largement obsolète.

• La notation hongroise crée de la confusion lorsqu'elle est utilisée pour représenter plusieurs propriétés, comme dans a_crszkvc30LastNameCol: un argument de référence constant, contenant le contenu d'une colonne LastNamede type base de données varchar(30)faisant partie de la clé primaire de la table.

• Cela peut entraîner des incohérences lorsque le code est modifié ou transféré. Si le type d'une variable est modifié, la décoration sur le nom de la variable sera incompatible avec le nouveau type ou le nom de la variable doit être modifié. Un exemple particulièrement connu est le WPARAMtype standard et le wParamparamètre formel associé dans de nombreuses déclarations de fonctions système Windows. Le «w» signifie «mot», où «mot» est la taille de mot native de l'architecture matérielle de la plate-forme. C'était à l'origine un type 16 bits sur les architectures de mots 16 bits, mais il a été remplacé par une architecture 32 bits sur des architectures de mots 32 bits ou un type 64 bits sur des architectures de mots 64 bits dans les versions ultérieures du système d'exploitation, tout en conservant sa nom original (son véritable type sous-jacent estUINT_PTR, c’est-à-dire un entier non signé suffisamment grand pour contenir un pointeur). L'impédance sémantique, et par conséquent la confusion et l'incohérence des programmeurs d'une plate-forme à l'autre, reposent sur l'hypothèse que "w" signifie 16 bits dans ces différents environnements.

• La plupart du temps, connaître l'utilisation d'une variable implique de connaître son type. De plus, si l'utilisation d'une variable n'est pas connue, elle ne peut pas être déduite de son type.

• La notation hongroise réduit fortement les avantages liés à l'utilisation d'éditeurs de code riches en fonctionnalités prenant en charge la complétion des noms de variables, car le programmeur doit d'abord saisir le spécificateur de type complet.

• Cela rend le code moins lisible, en obscurcissant le but de la variable avec des préfixes de type et de portée inutiles.

• Les informations de type supplémentaires peuvent insuffisamment remplacer des noms plus descriptifs. Eg sDatabasene dit pas au lecteur ce que c'est. databaseNamepourrait être un nom plus descriptif.

• Lorsque les noms sont suffisamment descriptifs, les informations de type supplémentaires peuvent être redondantes. Eg firstNameest probablement une chaîne. Donc, le nommer sFirstNameajoute seulement du fouillis au code.

Je n'utilise pas moi-même cette notation, car je n'aime pas le bruit technique inutile. Je sais presque toujours à quel type de fichier je fais affaire et je veux un langage clair dans mon modèle de domaine, mais j'écris principalement dans des langages statiques et fortement typés.

En tant que problème spécifique à MS SQL Server:

Toutes les procédures stockées précédées de «sp_» sont d'abord recherchées dans la base de données principale plutôt que dans celle dans laquelle elles ont été créées. Cela retardera l'exécution de la procédure stockée.

OMI le plus grand avantage de ne pas utiliser le hongrois est le fait qu'il vous oblige à utiliser des noms significatifs . Si vous nommez les variables correctement, vous devez immédiatement savoir de quel type il s'agit ou pouvoir le déduire assez rapidement dans tout système bien conçu. Si vous devez vous appuyer sur strou sur l’ blnensemble des objpréfixes pour savoir quel type de variable est, j’arguerais que cela indique un problème de dénomination - soit des noms de variable médiocres en général, soit bien trop génériques pour donner un sens.

Ironiquement, par expérience personnelle, le scénario principal que j’ai vu utiliser en hongrois est soit une programmation "culte du fret" (c’est-à-dire que d’autres codes l’utilisent, alors continuons à l’utiliser simplement parce que), ou dans VB.NET pour éviter le fait que la langue est insensible à la casse (par exemple Person oPerson = new Personparce que vous ne pouvez pas utiliser Person person = new Personet qu'il Person p = new Personest trop vague); J'ai également vu préfixer "le" ou "mon" à la place (comme dans Person thePerson = new Personou plus laid Person myPerson = new Person), dans ce cas particulier.

J'ajouterai que la seule fois où j'utilise le hongrois a tendance à être pour les contrôles ASP.NET et c'est vraiment une question de choix. Je trouve cela très moche de taper TextBoxCustomerNameou CustomerNameTextBoxpar rapport au plus simple txtCustomerName, mais même cela semble "sale". Je pense qu'une sorte de convention de nommage devrait être utilisée pour les contrôles car il peut y avoir plusieurs contrôles affichant les mêmes données.

Je vais me concentrer sur SQL Server puisque vous en avez parlé. Je ne vois aucune raison de mettre 'tbl' devant une table. Vous pouvez simplement regarder n'importe quel code tSQL et distinguer une table en fonction de son utilisation. Vous ne voudriez jamais Select from stored_procedure.ou pas Select from table(with_param)comme une UDF ou Execute tblTableOrViewNameune procédure stockée.

Les tableaux peuvent être confondus avec une vue, mais en ce qui concerne leur utilisation. il n'y a pas de différence, alors à quoi ça sert? La notation hongroise peut vous faire gagner du temps dans SSMS (sous table ou vues?), Mais c'est à peu près tout.

Les variables peuvent présenter un problème, mais elles doivent être déclarées et vraiment, à quelle distance de votre déclaration declare envisagez-vous d'utiliser une variable? Faire défiler quelques lignes ne devrait pas être un gros problème, sauf si vous écrivez des procédures très longues. Ce peut être une bonne idée de casser un peu le code long.

Ce que vous décrivez est une douleur, mais la solution de notation hongroise ne résout pas vraiment le problème. Vous pouvez consulter le code de quelqu'un d'autre et constater que le type de variable peut être modifié, ce qui nécessite à présent de modifier le nom de la variable. Encore une chose à oublier. Et si j’utilise un VarChar, vous devrez quand même regarder la déclaration de déclaration pour connaître la taille. Les noms descriptifs vous mèneront probablement plus loin. @PayPeriodStartDate s'explique à peu près tout seul.

Une autre chose à ajouter est que, quelles abréviations utiliseriez-vous pour un framework complet comme .NET? Oui, il est si simple de se rappeler que btnreprésente un bouton et txtune zone de texte. Cependant, qu'avez-vous en tête pour quelque chose comme StringBuilder? strbld? Qu'en est- il CompositeWebControl? Utilisez-vous quelque chose comme ceci:

CompositeWebControl comWCMyControl = new CompositeWebControl();

L’un des inconvénients de la notation hongroise était qu’avoir des cadres de plus en plus larges n’apportait pas non plus un avantage supplémentaire, mais aussi une complexité accrue pour les développeurs, car ils devaient maintenant apprendre de plus en plus les préfixes non standards.

À mon sens, la notation hongroise est un prétexte pour contourner un système de typage insuffisamment puissant. Dans les langages qui vous permettent de définir vos propres types, il est relativement simple de créer un nouveau type qui code le comportement que vous attendez. Dans son discours sur la notation hongroise, Joel Spolsky donne un exemple d'utilisation permettant de détecter d'éventuelles attaques XSS en indiquant qu'une variable ou une fonction est non sécurisée (us) ou sûre (s), mais que le programmeur doit quand même procéder à une vérification visuelle. Si vous avez plutôt un système de type extensible, vous pouvez simplement créer deux nouveaux types, UnsafeString et SafeString, puis les utiliser comme il convient. En prime, le type d'encodage devient:

SafeString encode(UnsafeString)

et ne pas avoir accès aux éléments internes de UnsafeString ou d’utiliser d’autres fonctions de conversion devient le seul moyen de passer d’un UnsafeString à un SafeString. Si toutes vos fonctions de sortie ne prennent que des instances de SafeString, il devient impossible de générer une chaîne non échappée [shenanigans avec conversions telles que StringToSafeString (someUnsafeString.ToString ())].

Il devrait être évident pourquoi autoriser le système de types à vérifier votre code est plus avantageux que d'essayer de le faire à la main, ou peut-être dans les yeux.

Dans une langue telle que C, bien sûr, vous vous trompez: un int est un int est un int, et vous ne pouvez rien faire à ce sujet. Vous pouvez toujours jouer à des jeux avec des structures, mais il est discutable de savoir si c'est une amélioration ou non.

En ce qui concerne l’autre interprétation de la notation hongroise, IE préfixant le type de la variable, c’est tout simplement stupide et encourage les pratiques paresseuses comme la dénomination de variables uivxwFoo au lieu de quelque chose de significatif comme countOfPeople.

La notation hongroise est presque complètement inutile dans une langue typée statiquement. C'est une fonctionnalité de base de l'EDI qui permet d'afficher le type d'une variable en plaçant la souris dessus ou par un autre moyen. de plus, vous pouvez voir quel est le type en regardant quelques lignes vers le haut où il a été déclaré, s'il n'y a pas d'inférence de type. Le point essentiel de l'inférence de type est de ne pas répéter le bruit du type partout, donc la notation hongroise est généralement considérée comme une mauvaise chose dans les langues avec inférence de type.

Dans les langues à typage dynamique, cela peut aider parfois, mais pour moi, cela ne semble pas idiomatique. Vous avez déjà abandonné vos fonctions en vous limitant aux domaines / codomaines exacts; si toutes vos variables sont nommées avec la notation hongroise, vous ne faites que reproduire ce qu'un système de type vous aurait donné. Comment exprimez-vous une variable polymorphe pouvant être un entier ou une chaîne en notation hongroise? "IntStringX"? "IntOrStringX"? Le seul endroit où j'ai utilisé la notation hongroise était dans le code d'assemblage, car j'essayais de récupérer ce que j'obtiendrais si j'avais un système de texte, et c'était la première chose que j'ai codée.

En tout cas, je me moque de ce que les gens nomment leurs variables, le code sera probablement toujours aussi incompréhensible. Les développeurs perdent beaucoup trop de temps sur des choses comme le style et les noms de variables, et à la fin de la journée, vous avez toujours une tonne de bibliothèques avec des conventions complètement différentes dans votre langue. Je développe un langage symbolique (c'est-à-dire: non textuel) où il n'y a pas de noms de variables, mais uniquement des identificateurs uniques et des noms suggérés pour les variables (mais la plupart des variables n'ont toujours pas de nom suggéré, car il n'existe tout simplement pas de nom raisonnable. leur); lors de l'audit de code non approuvé, vous ne pouvez pas dépendre de noms de variables.

Comme d'habitude, dans ce cas, je posterai une réponse avant de lire les réponses des autres participants. 

Je vois trois "bugs" dans votre vision: 

1) Si vous voulez connaître le type d'une variable / paramètre / attribut / colonne, vous pouvez survoler votre souris ou cliquer dessus pour l'afficher, dans la plupart des environnements de développement modernes. Je ne sais pas quels outils vous utilisez, mais la dernière fois que j'ai été forcé de travailler dans un environnement qui ne fournissait pas cette fonctionnalité, c'était au 20ème siècle, le langage était COBOL, oups non, c'était Fortran et mon patron. Je n'ai pas compris pourquoi je suis parti. 

2 / Les types peuvent changer au cours du cycle de développement. Un entier de 32 bits peut devenir un entier de 64 bits à un moment donné, pour de bonnes raisons qui n'avaient pas été détectées au début du projet. Donc, renommer intX en longX ou le laisser avec un nom qui pointe vers le mauvais type est un mauvais karma. 

3) Ce que vous demandez est en fait une redondance. La redondance n'est pas un très bon modèle de conception ou habitude. Même les humains hésitent à trop de redondance. Même les humains hésitent à trop de redondance. 

Je crois que le besoin criant d’hongrois est un symptôme .
Un symptôme de trop de variables globales ... ou de fonctions trop longues pour être maintenues .

Si votre définition de variable n'est pas visible, vous avez généralement des problèmes.
Et si vos fonctions ne suivent pas une convention mémorable , là encore, gros problème.

C'est ... à peu près la raison pour laquelle de nombreux lieux de travail se précipitent, je suppose.

Cela provenait de langues qui en avaient besoin .
Sur les temps de variables globales bonanza . (faute d’alternatives)
Cela nous a bien servi.

La seule utilisation réelle que nous avons pour aujourd'hui est le Joel Spolsky un .
Suivre certains attributs particuliers de la variable, comme sa sécurité .

( par exemple "La variable safeFoobara- t- elle le feu vert pour être injectée dans une requête SQL?
- Comme on l'appelle safe, oui")

D'autres réponses ont parlé des fonctionnalités de l'éditeur qui permettaient de voir le type d'une variable lorsque vous la survoliez. À mon avis, ces problèmes sont également problématiques pour la santé mentale du code . Je crois qu’elles n’ont été conçues que pour la refactorisation , comme beaucoup d’autres fonctionnalités (comme le pliage de fonctions) et ne devraient pas être utilisées avec du nouveau code.

Je pense que les autres affiches ont bien couvert les raisons de ne pas utiliser la notation hongroise. Je suis d'accord avec leurs commentaires.

Avec les bases de données, j'utilise la notation hongroise pour les objets DDL qui sont rarement utilisés dans le code, mais qui se heurteraient sinon dans les espaces de noms. Cela revient principalement à préfixer les index et les contraintes nommées avec leur type (PK, UK, FK et IN). Utilisez une méthode cohérente pour nommer ces objets et vous devriez pouvoir exécuter certaines validations en interrogeant les métadonnées.

la raison pour laquelle cela est évité est due aux systèmes hongrois qui violent DRY (le préfixe est exactement le type que le compilateur et (un bon) IDE peuvent dériver)

Préfixes OTOH en hongrois d'applications avec l' utilisation de la variable (ie, scrxMouse est la coordonnée ax sur l'écran, il peut s'agir d'un type int, court, long ou même personnalisé (les typedefs vous permettront même de le changer facilement))

le malentendu des systèmes est ce qui a détruit l'hongrois en tant que meilleure pratique

Disons que nous avons une méthode comme celle-ci (en C #):

int GetCustomerCount()
{
    // some code
}

Maintenant, dans le code, nous l'appelons comme ceci:

var intStuff = GetCustomerCount();
// lots of code that culminates in adding a customer
intStuff++;

Le int ne nous dit pas beaucoup. Le simple fait que quelque chose soit un int ne nous dit pas ce qu'il y a dedans. Supposons maintenant que nous l'appelons comme ceci:

var customerCount = GetCustomerCount();
// lots of code that culminates in adding a customer
customerCount++;

Nous pouvons maintenant voir quel est le but de la variable. Cela aurait-il de l'importance si nous savons que c'est un int?

Le but initial du hongrois, cependant, était de vous faire faire quelque chose comme ceci:

var cCustomers = GetCustomerCount();
// lots of code that culminates in adding a customer
cCustomers++;

C'est bien aussi longtemps que vous savez ce que c représente. Mais vous devriez avoir une table standard de préfixes, tout le monde devrait les connaître, et toute nouvelle personne devrait les apprendre pour comprendre votre code. Alors que customerCountou countOfCustomersest assez évident à première vue.

Le hongrois avait une certaine utilité dans VB avant d’ Option Strict Onexister, car VB6 et avant (et dans VB .NET avec Option Strict Off) VB contraignaient les types afin que vous puissiez le faire:

Dim someText As String = "5"
customerCount = customerCount + someText

C'est mauvais, mais le compilateur ne vous le dirait pas. Donc, si vous utilisiez le hongrois, vous auriez au moins un indicateur de ce qui se passait:

Dim strSomeText As String = "5"
intCustomerCount = intCustomerCount + strSomeText  // that doesn't look right!

Dans .NET, avec le typage statique, ce n'est pas nécessaire. Et le hongrois était trop souvent utilisé pour remplacer un bon nom. Oubliez le hongrois et choisissez de bons noms à la place.

J'ai trouvé beaucoup de bons arguments contre, mais je ne les ai pas vus: l'ergonomie.

Autrefois, quand vous n'aviez que string, int, bool et float, les caractères sibf auraient suffi. Mais avec string + short, les problèmes commencent. Utilisez le nom complet pour le préfixe ou str_name pour la chaîne? (Bien que les noms soient presque toujours des chaînes - n'est-ce pas?) Qu'est-ce qui se passe avec une classe de rue? Les noms deviennent de plus en plus longs, et même si vous utilisez CamelCase, il est difficile de savoir où se termine le préfixe de type et où commence le nom de la variable.

 BorderLayout boderLayoutInnerPanel = new BorderLayout ();
 panelInner.addLayout (borderLayoutInnerPanel);

D'accord - vous pouvez utiliser des soulignements, si vous ne les utilisez pas déjà pour autre chose, ou utiliser CamelCase si vous les avez utilisés aussi longtemps:

 BorderLayout boderLayout_innerPanel = new BorderLayout ();
 panel_inner.addLayout (borderLayout_innerPanel);

 Border_layout boder_layoutInner_panel = new Border_layout ();
 panelInner.add_layout (border_layoutInner_panel);

C'est monstrueux et si vous le faites en conséquence, vous aurez

 for (int iI = 0; iI < iMax-1; ++iI)
     for (int iJ = iI; iJ < iMax; ++iMax) 
          int iCount += foo (iI, iJ); 

Soit vous finirez par utiliser des préfixes inutiles pour des cas triviaux, comme des variables de boucle ou count. Quand avez-vous récemment utilisé un court ou un long pour un compteur? Si vous faites des exceptions, vous perdrez souvent du temps, pensant avoir besoin d'un préfixe ou non.

Si vous avez beaucoup de variables, elles sont normalement regroupées dans un navigateur d’objets qui fait partie de votre IDE. Maintenant, si 40% commencent par i_ pour int et 40% par s_ pour chaîne, et qu'ils sont triés par ordre alphabétique, il est difficile de trouver la partie significative du nom.

Le seul endroit où j'utilise toujours régulièrement des suffixes hongrois ou analogues est dans des contextes où les mêmes données sémantiques sont présentes sous deux formes différentes, comme la conversion de données. Cela peut se produire dans les cas où il existe plusieurs unités de mesure ou dans plusieurs formulaires (par exemple, String "123" et entier 123).

Je trouve que les raisons données ici pour ne pas l'utiliser sont impérieuses pour ne pas imposer le hongrois à d'autres, mais seulement légèrement suggestives, pour décider de votre propre pratique.

Le code source d'un programme est une interface utilisateur à part entière - affichant des algorithmes et des métadonnées au responsable - et la redondance des interfaces utilisateur est une vertu et non un péché . Voir, par exemple, les images de " La conception des choses de tous les jours ", et regardez les portes étiquetées "Push" qui ressemblent à celles que vous tirez, et les chopes de bière que les opérateurs ont piraté sur les contrôles importants du réacteur nucléaire parce que eux dans l'IDE "n'était pas assez bon.

Le "survol dans un IDE" n’est pas une raison pour ne pas utiliser le hongrois - c’est une raison pour laquelle certaines personnes pourraient ne pas le trouver utile. Votre kilométrage peut différer.

L'idée que Hongrois impose un lourd fardeau de maintenance lorsque les types de variables changent est stupide - à quelle fréquence modifiez-vous les types de variables? De plus, renommer les variables est facile:

Utilisez simplement l'EDI pour renommer toutes les occurrences. -Gander, répondant à l'oie

Si le hongrois vous aide vraiment à gérer rapidement un morceau de code et à le maintenir de manière fiable, utilisez-le. Si non, ne le faites pas. Si d'autres personnes vous disent que vous vous trompez au sujet de votre propre expérience, je dirais qu'elles sont probablement celles qui se trompent.