Pourquoi ne devrais-je pas utiliser la «notation hongroise»?

Je sais à quoi le hongrois fait référence – donner des informations sur une variable, un paramètre ou un type en tant que préfixe de son nom. Tout le monde semble être contre, même si dans certains cas, cela semble être une bonne idée. Si je sens que des informations utiles sont communiquées, pourquoi ne devrais-je pas les mettre là où elles sont disponibles?

Voir aussi: Les gens utilisent-ils les conventions de nommage hongroises dans le monde réel?

La plupart des gens utilisent la notation hongroise dans le mauvais sens et obtiennent des résultats erronés.

Lisez cet excellent article de Joel Spolsky: Wrong Code Wrong Code .

En bref, la notation hongroise où vous préfixez vos noms de variables avec leur type (chaîne) (systèmes hongrois) est mauvais car inutile.

La notation hongroise telle qu’elle était destinée par son auteur, où vous préfixez le nom de la variable avec son kind (en utilisant l’exemple de Joel: chaîne sécurisée ou chaîne non sécurisée), ainsi appelé Apps, le hongrois est utile et toujours utile.

vUtiliser adjHungarian nnotation vmakes nreading ncode adjdiff difficile.

Joel a tort, et voici pourquoi.

Cette information “application” dont il parle devrait être encodée dans le système de type . Vous ne devez pas dépendre du renversement des noms de variables pour vous assurer de ne pas transmettre de données dangereuses à des fonctions nécessitant des données sécurisées. Vous devriez en faire une erreur de type, de sorte qu’il soit impossible de le faire. Toute donnée non sécurisée doit avoir un type marqué comme non sûr, de sorte qu’il ne peut simplement pas être transmis à une fonction sécurisée. Pour passer de dangereux à sûr, il faut traiter avec une sorte de fonction de désinfection.

Beaucoup de choses dont Joel parle comme “types” ne sont pas des genres; ce sont en fait des types.

Ce qui manque à la plupart des langues, cependant, c’est un système de caractères suffisamment expressif pour imposer ce type de distinction. Par exemple, si C avait une sorte de “typedef fort” (où le nom typedef avait toutes les opérations du type de base, mais ne pouvait pas y être converti), beaucoup de ces problèmes disparaîtraient. Par exemple, si vous pouviez dire strong typedef std::ssortingng unsafe_ssortingng; pour introduire un nouveau type unsafe_ssortingng qui ne pourrait pas être converti en std :: ssortingng (et pourrait donc participer à la résolution de surcharge, etc., alors nous n’aurions pas besoin de préfixes idiots).

Ainsi, l’affirmation centrale selon laquelle le hongrois est pour des choses qui ne sont pas des types est erronée. Il est utilisé pour les informations de type. Informations de type plus riches que les informations de type C traditionnelles, certainement; C’est une information de type qui code une sorte de détail sémantique pour indiquer le but des objects. Mais c’est toujours l’information de type, et la solution appropriée a toujours été de l’encoder dans le système de type. Le coder dans le système de type est de loin le meilleur moyen d’obtenir une validation et une application correctes des règles. Les noms de variables ne coupent tout simplement pas la moutarde.

En d’autres termes, le but ne devrait pas être de “faire en sorte que le code ne soit pas correct pour le développeur”. Il faut “faire en sorte que le code ne soit pas correct pour le compilateur “.

Je pense que cela encombre massivement le code source.

Il ne vous gagne pas non plus beaucoup dans une langue fortement typée. Si vous utilisez n’importe quelle forme de type mismatch tomfoolery, le compilateur vous en informera.

La notation hongroise n’a de sens que dans les langues sans types définis par l’utilisateur . Dans un langage fonctionnel ou un langage OO moderne, vous encoderiez des informations sur le “type” de valeur dans le type de données ou la classe plutôt que dans le nom de la variable.

Plusieurs réponses font référence à l’ article de Joels . Notez toutefois que son exemple est dans VBScript, qui ne supporte pas les classes définies par l’utilisateur (au moins depuis longtemps). Dans un langage avec des types définis par l’utilisateur, vous résoudriez le même problème en créant un type HtmlEncodedSsortingng, puis en laissant la méthode Write uniquement accepter cela. Dans un langage de type statique, le compilateur détectera toutes les erreurs de codage, dans une exception dynamic, vous obtiendrez une exception d’exécution – mais dans tous les cas, vous êtes protégé contre l’écriture de chaînes non codées. Les notations hongroises transforment simplement le programmeur en un vérificateur de type humain, avec le type de travail généralement mieux géré par le logiciel.

Joel fait la distinction entre les “systèmes hongrois” et les “applications hongroises”, où “systèmes hongrois” encode les types intégrés tels que int, float, etc., et “apps hongrois” code les “types” à propos de la variable au-delà du type de machine, Dans un langage fonctionnel ou OO, vous pouvez créer des types définis par l’utilisateur. Il n’y a donc pas de distinction entre le type et le type. Hongrois est tout aussi redondant que les “systèmes” hongrois.

Donc, pour répondre à votre question: les systèmes hongrois ne seraient utiles que dans un langage peu sûr et faiblement typé où, par exemple, l’atsortingbution d’une valeur flottante à une variable int entraînerait le blocage du système. La notation hongroise a été spécifiquement inventée dans les années soixante pour être utilisée dans la BCPL , un langage de bas niveau qui ne vérifiait pas du tout le type. Je ne pense pas qu’une langue en usage aujourd’hui ait ce problème, mais la notation a survécu comme une sorte de programmation culte de la cargaison .

Les applications hongroises auront du sens si vous travaillez avec une langue sans types définis par l’utilisateur, comme VBScript hérité ou les premières versions de VB. Peut-être aussi les premières versions de Perl et de PHP. Encore une fois, l’utiliser dans une langue moderne est un pur culte de la cargaison.

Dans toute autre langue, le hongrois est tout simplement laid, redondant et fragile. Il répète les informations déjà connues du système de type et vous ne devez pas vous répéter . Utilisez un nom descriptif pour la variable qui décrit l’intention de cette instance spécifique du type. Utilisez le système de type pour coder les invariants et les méta-informations sur les “types” ou les “classes” de variables – c.-à-d. les types.

Le point général de l’article de Joels – avoir le mauvais code semble erroné – est un très bon principe. Cependant, une protection encore meilleure contre les bogues consiste à avoir, lorsque cela est possible, un code erroné à détecter automatiquement par le compilateur.

J’utilise toujours la notation hongroise pour tous mes projets. Je trouve cela très utile lorsque je traite de 100 noms d’identifiants différents.

Par exemple, lorsque j’appelle une fonction nécessitant une chaîne, je peux taper ‘s’ et bash l’espace de contrôle et mon IDE me montrera exactement les noms de variables précédés de ‘s’.

Un autre avantage, lorsque je préfixe u pour non signé et i pour les ints signés, je vois immédiatement où je mixe signé et non signé de manière potentiellement dangereuse.

Je ne me souviens plus du nombre de fois où, dans une base de code énorme de 75 000 lignes, des bogues ont été causés (par moi et par d’autres également) en raison du nom des variables locales. Depuis lors, je préfixe toujours les membres avec ‘m_’

C’est une question de goût et d’expérience. Ne le frappez pas avant de l’avoir essayé.

Vous oubliez la raison numéro un d’inclure cette information. Cela n’a rien à voir avec vous, le programmeur. Cela a tout à voir avec la personne qui prend la route 2 ou 3 ans après avoir quitté l’entreprise qui doit lire ce genre de choses.

Oui, un EDI identifiera rapidement les types pour vous. Cependant, lorsque vous lisez de longs lots de code de règles métier, il est préférable de ne pas interrompre chaque variable pour déterminer son type. Lorsque je vois des choses comme strUserID, intProduct ou guiProductID, le temps de montée en puissance est beaucoup plus facile.

Je suis d’accord que MS est allé trop loin avec certaines de leurs conventions de nommage – je catégorise cela dans la stack “trop ​​d’une bonne chose”.

Les conventions de nommage sont de bonnes choses, à condition de les respecter. Je suis passé par assez de vieux code qui me ramène constamment à regarder les définitions pour autant de variables nommées de la même manière que je pousse “le boîtier de chameau” (comme il a été appelé à un travail précédent). En ce moment, je suis sur un travail qui contient plusieurs milliers de lignes de code ASP classique sans commentaire avec VBScript et c’est un cauchemar d’essayer de comprendre les choses.

Le fait de taper des caractères cryptiques au début de chaque nom de variable est inutile et montre que le nom de la variable en soi n’est pas suffisamment descriptif. La plupart des langues nécessitent de toute façon le type de variable lors de la déclaration, de sorte que les informations sont déjà disponibles.

Il y a aussi la situation où, pendant la maintenance, un type de variable doit changer. Exemple: si une variable déclarée comme “uint_16 u16foo” doit devenir non signée sur 64 bits, l’une des deux choses suivantes se produira:

  1. Vous allez parcourir et modifier chaque nom de variable (en veillant à ne pas utiliser de variables non apparentées portant le même nom), ou
  2. Changez simplement le type et ne changez pas le nom, ce qui ne provoquera que confusion.

Joel Spolsky a écrit un bon article sur ce sujet. http://www.joelonsoftware.com/articles/Wrong.html En gros, cela revient à ne pas rendre votre code plus difficile à lire lorsqu’un IDE décent vous dira que le type est la variable si vous ne vous en souvenez pas. De plus, si votre code est suffisamment compartimenté, vous n’avez pas à vous souvenir de ce qu’une variable a été déclarée en trois pages.

La scope n’est-elle pas plus importante que la saisie ces jours-ci, par exemple

 * l for local * a for argument * m for member * g for global * etc 

Avec les techniques modernes de refactorisation de l’ancien code, la recherche et le remplacement d’un symbole parce que son type est fastidieux, le compilateur intercepte les modifications de type, mais n’utilise souvent pas l’étendue.

Il n’y a aucune raison pour laquelle vous ne devriez pas utiliser correctement la notation hongroise. Son impopularité est due à un long retour en arrière contre la mauvaise utilisation de la notation hongroise, en particulier dans les API Windows.

Dans les mauvais jours, avant que rien ne ressemble à un IDE ne existait pour DOS (il est probable que vous n’ayez pas assez de mémoire libre pour exécuter le compilateur sous Windows, votre développement a donc été fait sous DOS). en passant votre souris sur un nom de variable. (En supposant que vous aviez une souris.) Quelles étaient les fonctions de rappel d’événement dans lesquelles tout vous était transmis sous la forme d’un int 16 bits (WORD) ou de 32 bits int (LONG WORD). Vous devez ensuite convertir ces parameters en types appropriés pour le type d’événement donné. En effet, une grande partie de l’API était virtuellement sans type.

Le résultat, une API avec des noms de parameters comme ceux-ci:

 LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); 

Notez que les noms wParam et lParam, bien que très mauvais, ne sont pas vraiment plus mauvais que de les nommer param1 et param2.

Pour aggraver les choses, Windows 3.0 / 3.1 avait deux types de pointeurs, proches et éloignés. Ainsi, par exemple, la valeur de retour de la fonction de gestion de la mémoire LocalLock était un PVOID, mais la valeur renvoyée par GlobalLock était un LPVOID (avec le «L» pour longtemps). Cette affreuse notation a ensuite été étendue de manière à ce qu’une chaîne de caractères plus longue soit préfixée par lp , pour la distinguer d’une chaîne qui avait été simplement malloc.

Il n’est pas surprenant qu’il y ait eu un retour de bâton contre ce genre de chose.

La notation hongroise peut être utile dans les langues sans vérification de type à la compilation, car cela permettrait au développeur de se rappeler rapidement comment la variable particulière est utilisée. Il ne fait rien pour la performance ou le comportement. Il est censé améliorer la lisibilité du code et relève essentiellement du goût et du style de codage. Pour cette raison, il est critiqué par de nombreux développeurs – tout le monde n’a pas le même câblage dans le cerveau.

Pour les langages de vérification de type à la compilation, il est généralement inutile – faire défiler quelques lignes devrait révéler la déclaration et donc le type. Si vos variables globales ou votre bloc de code couvre beaucoup plus d’un écran, vous rencontrez de graves problèmes de conception et de réutilisation. L’une des critiques est que la notation hongroise permet aux développeurs d’avoir une mauvaise conception et de s’en sortir facilement. C’est probablement l’une des raisons de la haine.

D’un autre côté, il peut y avoir des cas où même les langages de vérification de type à la compilation pourraient bénéficier de la notation hongroise – pointeurs vides ou HANDLE dans l’API win32. Cela brouille le type de données réel, et il pourrait être intéressant d’utiliser la notation hongroise. Cependant, si l’on peut connaître le type de données au moment de la construction, pourquoi ne pas utiliser le type de données approprié.

En général, il n’y a pas de raisons de ne pas utiliser la notation hongroise. Il s’agit de goûts, de politiques et de style de codage.

En tant que programmeur Python, la notation hongroise s’effondre assez rapidement. En Python, peu m’importe si quelque chose est une chaîne – Je me soucie de savoir si elle peut agir comme une chaîne (c’est-à-dire si elle a une méthode ___str___() qui renvoie une chaîne).

Par exemple, supposons que foo soit un entier, 12

 foo = 12 

La notation hongroise nous dit que nous devrions appeler cela iFoo ou quelque chose, pour indiquer qu’il s’agit d’un entier, afin que nous sachions plus tard ce que c’est. Sauf en Python, cela ne fonctionne pas, ou plutôt, cela n’a pas de sens. En Python, je décide quel type je veux quand je l’utilise. Est-ce que je veux une ficelle? bien si je fais quelque chose comme ça:

 print "The current value of foo is %s" % foo 

Notez la chaîne %s . Foo n’est pas une chaîne, mais l’opérateur % appelle foo.___str___() et utilise le résultat (en supposant qu’il existe). foo est toujours un entier, mais nous le traitons comme une chaîne si nous voulons une chaîne. Si nous voulons un flotteur, nous le traitons comme un flotteur. Dans les langages typescripts dynamicment comme Python, la notation hongroise ne sert à rien, quel que soit le type d’utilisation de quelque chose jusqu’à ce que vous l’utilisiez, et si vous avez besoin d’un type spécifique, assurez-vous de le float(foo) ) lorsque vous l’utilisez.

Notez que les langages dynamics comme PHP n’ont pas cet avantage – PHP essaie de faire «la bonne chose» en arrière-plan en se basant sur un ensemble obscur de règles que personne n’a mémorisé, ce qui entraîne souvent des dégâts catastrophiques inattendus. Dans ce cas, une sorte de mécanisme de nommage, comme $files_count ou $file_name , peut être utile.

À mon avis, la notation hongroise est comme les sangsues. Peut-être que dans le passé, ils étaient utiles, ou du moins ils semblaient utiles, mais de nos jours, il ne s’agit que de beaucoup de frappe supplémentaire, ce qui n’est pas très bénéfique.

L’EDI doit communiquer ces informations utiles. Le hongrois aurait pu faire quelque chose (pas beaucoup, mais une sorte) de sens lorsque les IDE étaient beaucoup moins avancés.

Apps Le hongrois est grec pour moi – dans le bon sens

En tant qu’ingénieur et non programmeur, j’ai immédiatement consulté l’article de Joel sur les mérites de Apps Hungarian: “Wrong Code Look Wrong Wrong” . J’aime Apps Hungarian car il imite la façon dont l’ingénierie, la science et les mathématiques représentent des équations et des formules utilisant des symboles sous-et super-scriptés (comme les lettres grecques, les opérateurs mathématiques, etc.). Prenons un exemple particulier de la loi de Newton sur la gravité universelle : d’abord en notation mathématique standard, puis dans le pseudo-code hongrois Apps:

Loi universelle de gravité de Newton pour la Terre et Mars

 frcGravityEarthMars = G * massEarth * massMars / norm(posEarth - posMars) 

Dans la notation mathématique, les symboles les plus importants sont ceux représentant le type d’informations stockées dans la variable: force, masse, vecteur de position, etc. Les indices jouent le second rôle pour clarifier: la position de quoi? C’est exactement ce que font les applications hongroises; il vous indique le type de chose stocké dans la variable en premier, puis en entrant dans les détails – à propos du code le plus proche peut arriver à la notation mathématique.

Il est clair que le typage fort peut résoudre l’exemple de Joel, mais vous ne définissez pas de types distincts pour les vecteurs de position et de vitesse. les deux sont des tableaux doubles de taille trois et tout ce que vous êtes susceptible de faire pour l’un pourrait s’appliquer à l’autre. De plus, il est parfaitement logique de concaténer la position et la vitesse (pour créer un vecteur d’état) ou de prendre leur produit scalaire, mais probablement de ne pas les append. Comment la dactylographie autoriserait-elle les deux premières et interdirait-elle la seconde, et comment un tel système s’étendrait-il à toutes les opérations que vous pourriez vouloir protéger? À moins que vous ne vouliez encoder toutes les mathématiques et la physique dans votre système de frappe.

En plus de tout cela, beaucoup d’ingénierie est faite dans des langages de haut niveau faiblement typés comme Matlab, ou d’anciens comme Fortran 77 ou Ada.

Donc, si vous avez un langage sophistiqué et IDE et Apps hongrois ne vous aide pas alors l’oublier – beaucoup de gens ont apparemment. Mais pour moi, pire qu’un programmeur novice qui travaille dans des langages typés faiblement ou dynamicment, je peux écrire plus rapidement du code avec Apps Hungarian qu’avec sans.

La plupart des IDE modernes sont incroyablement redondants et inutiles, car ils font un bon travail pour rendre le type apparent.

De plus, pour moi, il est ennuyeux de voir intI, strUserName, etc. 🙂

Si je sens que des informations utiles sont communiquées, pourquoi ne devrais-je pas les mettre là où elles sont disponibles?

Alors, qu’est-ce que quelqu’un d’autre pense? Si vous le trouvez utile, utilisez la notation.

Im mon expérience, c’est mauvais parce que:

1 – alors vous casser tout le code si vous avez besoin de changer le type d’une variable (c’est-à-dire si vous devez étendre un entier de 32 bits à un entier de 64 bits);

2 – ceci est une information inutile car le type est déjà dans la déclaration ou vous utilisez un langage dynamic où le type réel ne devrait pas être si important en premier lieu.

De plus, avec un langage acceptant une programmation générique (c.-à-d. Des fonctions où le type de certaines variables n’est pas déterminé lorsque vous écrivez la fonction) ou avec un système de typage dynamic (lorsque le type n’est même pas déterminé au moment de la compilation), comment des variables? Et la plupart des langues modernes prennent en charge l’une ou l’autre, même sous une forme restreinte.

Dans Making Wrong Code Look Wrong de Joel Spolsky, il explique que ce que tout le monde pense comme la notation hongroise (qu’il appelle Systems Hungarian) n’est pas ce qu’il était censé être (ce qu’il appelle des applications en hongrois). Descendez à la rubrique Je suis en Hongrie pour voir cette discussion.

Fondamentalement, Systems Hungarian est sans valeur. Il vous indique simplement la même chose que votre compilateur et / ou votre IDE vous dira.

Apps hongrois vous indique ce que la variable est censée signifier et peut réellement être utile.

J’ai toujours pensé qu’un préfixe ou deux au bon endroit ne feraient pas de mal. Je pense que si je peux transmettre quelque chose d’utile, comme “Hé, c’est une interface, ne comptez pas sur des comportements spécifiques”, comme dans IEnumerable, je le fais. Les commentaires peuvent encombrer beaucoup plus qu’un simple symbole d’un ou deux caractères.

C’est une convention utile pour nommer des contrôles sur un formulaire (btnOK, txtLastName, etc.), si la liste des contrôles apparaît dans une liste déroulante alphabétique de votre IDE.

J’ai tendance à utiliser la notation hongroise avec les contrôles serveur ASP.NET uniquement , sinon je trouve trop difficile de déterminer quels sont les contrôles du formulaire.

Prenez cet extrait de code:

    

Si quelqu’un peut montrer une meilleure façon d’avoir cet ensemble de noms de contrôle sans hongrois, je serais tenté d’y aller.

L’article de Joel est génial, mais il semble omettre un point majeur:

Le hongrois rend une «idée» particulière (genre + nom identifiant) unique ou quasi-unique sur la base de code – même une base de code très volumineuse.

C’est énorme pour la maintenance du code. Cela signifie que vous pouvez utiliser la bonne recherche de texte sur une seule ligne (grep, findstr, ‘find in all files’) pour trouver CHAQUE mention de cette idée.

Pourquoi est-ce important lorsque nous avons des IDE qui savent lire le code? Parce qu’ils ne sont pas encore très bons. C’est difficile à voir dans une petite base de code, mais évidente dans une grande taille – lorsque l’idée peut être mentionnée dans les commentaires, les fichiers XML, les scripts Perl et dans des endroits extérieurs au contrôle des sources (documents, wikis, bases de données de bogues).

You do have to be a little careful even here – eg token-pasting in C/C++ macros can hide mentions of the identifier. Such cases can be dealt with using coding conventions, and anyway they tend to affect only a minority of the identifiers in the codebase.

PS To the point about using the type system vs. Hungarian – it’s best to use both. You only need wrong code to look wrong if the comstackr won’t catch it for you. There are plenty of cases where it is infeasible to make the comstackr catch it. But where it’s feasible – yes, please do that instead!

When considering feasibility, though, do consider the negative effects of splitting up types. eg in C#, wrapping ‘int’ with a non-built-in type has huge consequences. So it makes sense in some situations, but not in all of them.

Debunking the benefits of Hungarian Notation

  • It provides a way of distinguishing variables.

If the type is all that distinguishes the one value from another, then it can only be for the conversion of one type to another. If you have the same value that is being converted between types, chances are you should be doing this in a function dedicated to conversion. (I have seen hungarianed VB6 leftovers use ssortingngs on all of their method parameters simply because they could not figure out how to deserialize a JSON object, or properly comprehend how to declare or use nullable types. ) If you have two variables distinguished only by the Hungarian prefix, and they are not a conversion from one to the other, then you need to elaborate on your intention with them.

  • It makes the code more readable.

I have found that Hungarian notation makes people lazy with their variable names. They have something to distinguish it by, and they feel no need to elaborate to its purpose. This is what you will typically find in Hungarian notated code vs. modern: sSQL vs. groupSelectSql ( or usually no sSQL at all because they are supposed to be using the ORM that was put in by earlier developers. ), sValue vs. formCollectionValue ( or usually no sValue either, because they happen to be in MVC and should be using its model binding features ), sType vs. publishSource, etc.

It can’t be readability. I see more sTemp1, sTemp2… sTempN from any given hungarianed VB6 leftover than everybody else combined.

  • It prevents errors.

This would be by virtue of number 2, which is false.

In the words of the master:

http://www.joelonsoftware.com/articles/Wrong.html

An interesting reading, as usual.

Extracts:

“Somebody, somewhere, read Simonyi’s paper, where he used the word “type,” and thought he meant type, like class, like in a type system, like the type checking that the comstackr does. He did not. He explained very carefully exactly what he meant by the word “type,” but it didn’t help. The damage was done.”

“But there’s still a tremendous amount of value to Apps Hungarian, in that it increases collocation in code, which makes the code easier to read, write, debug, and maintain, and, most importantly, it makes wrong code look wrong.”

Make sure you have some time before reading Joel On Software. 🙂

Plusieurs raisons:

  • Any modern IDE will give you the variable type by simply hovering your mouse over the variable.
  • Most type names are way long (think HttpClientRequestProvider ) to be reasonably used as prefix.
  • The type information does not carry the right information, it is just paraphrasing the variable declaration, instead of outlining the purpose of the variable (think myInteger vs. pageSize ).

I don’t think everyone is rabidly against it. In languages without static types, it’s pretty useful. I definitely prefer it when it’s used to give information that is not already in the type. Like in C, char * szName says that the variable will refer to a null terminated ssortingng — that’s not implicit in char* — of course, a typedef would also help.

Joel had a great article on using hungarian to tell if a variable was HTML encoded or not:

http://www.joelonsoftware.com/articles/Wrong.html

Anyway, I tend to dislike Hungarian when it’s used to impart information I already know.

Of course when 99% of programmers agree on something, there is something wrong. The reason they agree here is because most of them have never used Hungarian notation correctly.

For a detailed argument, I refer you to a blog post I have made on the subject.

http://codingthriller.blogspot.com/2007/11/rediscovering-hungarian-notation.html

I started coding pretty much the about the time Hungarian notation was invented and the first time I was forced to use it on a project I hated it.

After a while I realised that when it was done properly it did actually help and these days I love it.

But like all things good, it has to be learnt and understood and to do it properly takes time.

The Hungarian notation was abused, particularly by Microsoft, leading to prefixes longer than the variable name, and showing it is quite rigid, particularly when you change the types (the infamous lparam/wparam, of different type/size in Win16, identical in Win32).

Thus, both due to this abuse, and its use by M$, it was put down as useless.

At my work, we code in Java, but the founder cames from MFC world, so use similar code style (aligned braces, I like this!, capitals to method names, I am used to that, prefix like m_ to class members (fields), s_ to static members, etc.).

And they said all variables should have a prefix showing its type (eg. a BufferedReader is named brData). Which shown as being a bad idea, as the types can change but the names doesn’t follow, or coders are not consistent in the use of these prefixes (I even see aBuffer, theProxy, etc.!).

Personally, I chose for a few prefixes that I find useful, the most important being b to prefix boolean variables, as they are the only ones where I allow syntax like if (bVar) (no use of autocast of some values to true or false). When I coded in C, I used a prefix for variables allocated with malloc, as a reminder it should be freed later. Etc.

So, basically, I don’t reject this notation as a whole, but took what seems fitting for my needs.
And of course, when consortingbuting to some project (work, open source), I just use the conventions in place!