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

101

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?

utilisateur29981
la source
39
Quelle langue / IDE utilisez-vous? Dans Visual Studio, vous n'avez pas besoin de consulter la définition pour connaître le type d'une variable, car l'EDI vous le fournit. Dans les langues où les types ne sont pas appliqués, comme PHP, vous n'avez pas besoin de connaître le type la plupart du temps (vous pouvez affecter 0 ou 1 à un booléen).
Arseni Mourzenko
10
@MainMa Je ne suis pas sûr que ce soit une bonne raison de ne pas connaître le type d'une valeur en PHP.
Rei Miyasaka
29
"Quand les projets prennent de l'ampleur" ... ne devrait pas avoir d'importance. Il ne devrait y avoir qu'un petit nombre de variables dans la portée à un moment donné: une poignée de variables de classe et une autre poignée d'arguments de méthode. Si vous ne pouvez pas les garder droites, alors la classe est trop grande ou la méthode est trop longue. La notation hongroise a été inventée pour la programmation Windows C, essentiellement comme solution de contournement pour l’API Windows horrible. Rien de semblable n'a jamais été suggéré ou voulu pour le développement Unix.
kevin cline
20
quel est l'avantage de ne pas utiliser la notation hongroise « Ne pas être haï par vos collègues » vient à l' esprit ...
Sean Patrick Floyd
25
adjHungarian nNotation vIs PRÉPARATIFS vRead.
dan04

Réponses:

148

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 ...
Marjan Venema
la source
9
@ Surfer513: En fait, je préfère les suffixes pour nommer les contrôles. Pour moi, il est beaucoup plus intéressant de trouver tous les contrôles qui traitent d'un sujet / aspect spécifique que de trouver tous les contrôles d'édition ... Lorsque je veux trouver le contrôle où l'utilisateur peut taper un nom de client, je commence à chercher client plutôt que txt, car il pourrait ne pas s'agir d'un txt (édition) mais d'un mémo, d'un richedit ou d'un ... Peut-être même une liste déroulante permettant de le trouver dans les noms de clients entrés précédemment ...
Marjan Venema
8
@ Surfer513: Et aujourd'hui, j'ai tendance à utiliser des suffixes uniquement pour distinguer deux contrôles traitant de la même chose. Par exemple, l'étiquette et la modification du nom du client. Et bien souvent, les suffixes ne sont pas liés au type de contrôle, mais à sa fonction: ClientCaption et ClientInput par exemple.
Marjan Venema
3
Il est également intéressant de noter qu'intelliSense dans VS 2010 vous permet de rechercher le nom complet , pas seulement le début. Si vous nommez votre contrôle "firstNameTextBox" et tapez "textb", il trouvera votre contrôle et le listera.
Adam Robinson
4
"... la version maltraitée est évitée comme la plaque ..." c'est-à-dire évitée un peu moins que le tartre et la gingivite? ;-)
Ben Mosher
4
@Marjan: Bien sûr, un compilateur aurait pu le comprendre. Si chaque unité est représentée par un type, vous ne pouvez pas en transmettre accidentellement une autre. Ici, si vous avez a AbsoluteXTypeet a RelativeYType, vous ne pouvez pas transmettre par erreur une coordonnée relative Y pour une coordonnée X absolue. Je préfère que les variables qui représentent des entités incompatibles soient de types incompatibles, plutôt que d'avoir des préfixes incompatibles. Le compilateur ne se soucie pas des préfixes (ou des suffixes).
Matthieu M.
74

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.

utilisateur7519
la source
2
"Que se passe-t-il lorsque vous changez intde type, par exemple long..." Simple: <sarcasme> Ne changez pas le nom car rien ne permet de savoir combien de fois le changement se répercutera. </ Sarcasm> Vous avez maintenant une variable dont Le nom hongrois est en conflit avec sa mise en œuvre. Il n'y a absolument aucun moyen de dire quelle sera l'ampleur des effets du changement de nom si la variable / fonction a une visibilité publique.
David Hammen
2
L'article lié est fantastique et mérite une lecture. +1
Marty Pitt
6
@ David n'a qu'à regarder l'API Win32 qui regorge de variables, de paramètres et même de noms de méthodes qui, à l'aide de la notation hongroise (qui est une exigence de la part de MS), indiquent une valeur de 8 bits ou de 16 bits alors qu'en réalité ils ont tous été 32 bits valeurs depuis l’introduction de Windows 95 en 1994 (il ya presque 17 ans).
Jwenting
2
@Secure: Je dirais que c'est ce que les tests automatisés devraient faire. Pas des programmeurs.
Joel
2
@Secure n'est peut-être pas dans une application interne, mais si vous maintenez une API publique telle que celle de Windows, c'est un problème majeur.
Jwenting
51

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.

Falcon
la source
1
Cela devrait être la bonne réponse. C'est si gentil. +1
Saeed Neamati
Tu es trop gentil, Saeed. J'apprécie votre appréciation, mais les autres réponses à cette question sont également très bonnes.
Falcon
11
Vote majoré pour une seule phrase: " La plupart du temps, connaître l'utilisation d'une variable implique de connaître son type. En outre, si l'utilisation d'une variable n'est pas connue, elle ne peut pas être déduite de son type. " - IMHO, c'est la raison n ° 1 d'éviter la notation hongroise.
Daniel Pryden
19

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.

tsundoku
la source
4
+1 pour des informations très cool là-bas. J'utilise 'sp' comme préfixe proc stocké, pas 'sp_'. Mais tout de même, c’est un fait très intéressant et une raison concrète de ne pas utiliser «sp_» comme préfixe proc stocké.
2
+1 Je ne le savais jamais et quand j'ai commencé à travailler sur SQL Server, tous les SP de mon lieu de travail étaient précédés d'un préfixe sp_, je me suis contenté de respecter la convention.
Michael
Excellent point, mais rien à voir avec cette question (Utilisation de sq et non _sp). C'est comme si vous omettiez le nom du schéma pour les objets qui ne sont pas dans le schéma par défaut.
JeffO
1
Pour les procédures stockées par l'utilisateur, j'utilisais classiquement «usp_». Cela a permis d'éviter le problème mentionné ET de distinguer pour le lecteur si le sproc était système ou utilisateur.
Parapluie
15

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.

Wayne M
la source
13

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.

JeffO
la source
2
@Surfer: une clé primaire est différente parce que "PK" n'est pas le type; "PK_TableName" dit "ceci est la clé primaire de TableName", pas "ceci est un TableName de type PK". Pour le reste ... il ne semble pas que vous écoutiez vraiment les arguments ici. S'il vous plaît, arrêtez d'utiliser cette pratique détestable qui persiste encore aujourd'hui à faire baisser la qualité collective de tout code.
Aaronaught
2
@Aaronaught, vous spécifiez un aspect de la notation hongroise ( en.wikipedia.org/wiki/Hungarian_notation ). Ce n'est pas juste le type, mais aussi l'utilisation prévue. Donc, préfixer 'pk' pour une clé primaire est en fait une notation hongroise. J'écoute les arguments ici, mais il y a des exceptions (comme la situation de clé principale) où il semble que HN soit bénéfique. Peut-être peut-être pas. J'essaie encore de comprendre ce qu'il faut faire et ce qu'il ne faut pas faire pour tous les scénarios. J'ai beaucoup appris à ce sujet aujourd'hui et suscité de bonnes réflexions.
3
@ Surfer: Ce n'est tout simplement pas correct. La notation hongroise décrit le type (version incorrecte) ou une utilisation particulière du type (version inférieure). PK non plus, il ne s'agit pas simplement de décrire quelque chose sur le type, mais bien de décrire un comportement . Lorsque je parle, par exemple, d’un âge, il est tout à fait inintéressant qu’il s’agisse d’un entier, mais lorsque vous parlez d’une contrainte de base de données, la clé primaire de la table X est exactement ce qui est important.
Aaronaught
4
J'aime votre avant-dernier paragraphe. La raison pour laquelle mon entreprise utilise la notation hongroise est la suivante: "Cela nous permet de voir rapidement quelles variables sont globales et quelles variables ne le sont pas." Et ensuite, vous regardez les déclarations de variables et il y a 300 variables par fichier, certaines m * pour modulaire (global), certaines v * pour local MÊME QU'ILS SOIENT DÉCLARÉS AU NIVEAU MODULAIRE. "Oh, c'est parce qu'ils sont juste destinés à être utilisés comme locaux, pas comme modulaires." facepalm
corsiKa
3
@Aaronaught: Dans mon projet actuel, nous utilisons des noms de table préfixés par tbl_ . Bien que je ne sois pas un grand fan de cette pratique, je ne vois pas en quoi cela "réduit la qualité collective de tout code" . Pouvez-vous peut-être donner un exemple?
Treb
6

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.

Saeed Neamati
la source
6

À 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.

Orclev
la source
Comment déclarer un type .NET ou Java de manière à décrire " int[]ce qui peut être librement modifié mais jamais partagé" ou " int[]qui ne peut être librement partagé que parmi des choses qui ne le modifieront jamais"? Si un int[]champ fooencapsule les valeurs, {1,2,3}peut-on le faire encapsuler {2,2,3}sans savoir quel "type" int[]en représente? Je pense que Java et .NET auraient été beaucoup mieux si - en l’absence de prise en charge du système de types, ils avaient au moins adopté une convention de dénomination pour distinguer ces types.
Supercat
4

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.

Longpoke
la source
C'est aussi assez inutile pour la plupart des langues typées dynamiquement!
James Anderson
2
pour les IDE, c'est encore pire que pour le codage manuel car cela signifie que l'achèvement du code est considérablement ralenti. Si vous avez 100 variables entières, taper int <alt-space> (par exemple) affiche 100 éléments à faire défiler. Si celui dont vous avez besoin est intVeryLongVariableName, l'achèvement de votre code devient problématique. Sans hongrois, il vous suffirait de taper très <alt-space> et de n’avoir que 1 ou 2 options.
Jwenting
3

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. 

Oqaqiq
la source
Je comprends l'IDE avancé / moderne et je suis tout à fait d'accord avec vous. Mais qu'en est-il de la conception de base de données? Supposons que vous ayez une colonne ou un paramètre de procédure stockée. L'astuce survol ne fonctionne pas vraiment avec ce genre de chose. Vous devriez regarder la définition de table / proc stockée. Que faites-vous pour ça?
3

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.

ZJR
la source
2

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.

BillThor
la source
Je trouve souvent que c'est le cas lorsque j'ai une table d'identifiants. Si j’ai TABLE SomeStringById(int somestringId, varchar somestring)l’index, c’est aussi logiquement, SomeStringByIdmais cela provoque une collision. Alors je l'appelle idx_SomeStringById. Ensuite, pour faire de même, je le ferai idx_SomeStringByValuesimplement parce que c’est idiot d’avoir le idx_sur l’un et pas sur l’autre.
CorsiKa
1

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

monstre à cliquet
la source
2
Je ne suis pas d'accord - ce qui a détruit le hongrois en tant que "meilleure pratique", c'est qu'il n'a jamais été proche de la meilleure (ou même de la bonne) pratique.
Jerry Coffin
2
@haylem: J'ai vu les articles et l'article original de Simonyi et lu le code. Dans tous les cas, c'est une mauvaise idée qui n'aurait jamais dû voir le jour.
Jerry Coffin
1
Cela ne viole pas nécessairement DRY dans un langage dynamique; c'est juste unidiomatic. DRY n'est pas forcément toujours bon; ex: macros C
Longpoke
3
Selon l’OMI, ce qui "détruit" le hongrois, c’est le fait que même "l’intention" n’est pas utile par rapport à l’utilisation de noms descriptifs , bien que pour être juste lorsque le hongrois a été créé, il n’existait aucun mouvement pour avoir du code lisible ...
Wayne Molina
1
@Wayne M: "noms descriptifs" est facile à dire lorsque les compilateurs vous permettent essentiellement d’utiliser un essai pour un nom de variable. Lorsque la longueur des noms d'identification ont été effectivement limité à une faible valeur assez arbitraire (je crois une limite commune était huit ou dix caractères pas que très il y a longtemps, je ne me souviens que même Borland Turbo C 2 avait une option de configuration pour la longueur maximale d'un nom d'identifiant!), encoder des informations utiles dans un nom était un peu plus compliqué ...
a CVn
1

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.

Kyralessa
la source
1

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.

Utilisateur inconnu
la source
1

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.

Ed Staub
la source