language-agnostic naming-conventions hungarian-notation

language agnostic - ¿Por qué no debería usar "notación húngara"?



language-agnostic naming-conventions (30)

Si siento que se imparte información útil, ¿por qué no debería ponerla allí donde esté disponible?

Entonces, ¿a quién le importa lo que piensen los demás? Si lo encuentras útil, utiliza la notación.

Sé a qué se refiere el húngaro, dando información sobre una variable, parámetro o tipo como un prefijo a su nombre. Todo el mundo parece estar en contra de ella, aunque en algunos casos parece ser una buena idea. Si siento que se imparte información útil, ¿por qué no debería ponerla allí donde esté disponible?

Vea también: ¿La gente usa las convenciones de nombres húngaros en el mundo real?

Aplicaciones El húngaro es griego para mí, en el buen sentido

Como ingeniero, no como programador, de inmediato tomé el artículo de Joel sobre los méritos de las aplicaciones húngaras: "Hacer que el código incorrecto parezca incorrecto" . Me gustan las aplicaciones húngaras porque imitan cómo la ingeniería, la ciencia y las matemáticas representan ecuaciones y fórmulas que usan símbolos sub y superguiados (como letras griegas, operadores matemáticos, etc.). Tomemos un ejemplo particular de la Ley de Gravedad Universal de Newton : primero en notación matemática estándar, y luego en el pseudocódigo húngaro de Apps:

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

En la notación matemática, los símbolos más prominentes son aquellos que representan el tipo de información almacenada en la variable: fuerza, masa, vector de posición, etc. Los subíndices juegan segundo violín para aclarar: posición de qué? Esto es exactamente lo que está haciendo Apps Hungarian; le está diciendo el tipo de cosas almacenadas en la variable primero y luego entrando en detalles, sobre el código más cercano que puede llegar a la notación matemática.

Claramente, la tipificación fuerte puede resolver el ejemplo de cadena segura vs. insegura del ensayo de Joel, pero no definiría tipos separados para los vectores de posición y velocidad; ambos son matrices dobles de tamaño tres y todo lo que es probable que le haga a uno podría aplicarse al otro. Además, tiene perfecto sentido concatenar posición y velocidad (para hacer un vector de estado) o tomar su producto de puntos, pero probablemente no para agregarlos. ¿De qué manera el tipado permitiría los dos primeros y prohibiría el segundo, y cómo se extendería ese sistema a cada operación posible que desee proteger? A menos que estuvieras dispuesto a codificar todas las matemáticas y la física en tu sistema de escritura.

Además de todo eso, mucha ingeniería se hace en lenguajes de alto nivel débilmente tipados como Matlab, o viejos como Fortran 77 o Ada.

Entonces, si tienes un lenguaje elegante e IDE y las aplicaciones húngaras no te ayudan, entonces olvídalo, aparentemente mucha gente lo tiene. Pero para mí, un programador novato que trabaja en lenguajes de tipado débil o dinámico, puedo escribir mejor código más rápido con aplicaciones húngaras que sin él.

Desprestigiar los beneficios de la notación húngara

  • Proporciona una forma de distinguir variables.

Si el tipo es todo lo que distingue un valor de otro, entonces solo puede ser para la conversión de un tipo a otro. Si tiene el mismo valor que se convierte entre los tipos, es probable que deba hacer esto en una función dedicada a la conversión. (I have seen hungarianed VB6 leftovers use strings 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.

¿No es el alcance más importante que el tipo en estos días, por ejemplo?

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

Con las técnicas modernas de refactorización de código antiguo, buscar y reemplazar un símbolo porque ha cambiado su tipo es tedioso, el compilador detectará cambios de tipo, pero a menudo no detectará el uso incorrecto del alcance, aquí las convenciones de nombres razonables ayudan.

Como programador de Python, la notación húngara se desmorona bastante rápido. En Python, no me importa si algo es una cadena, me importa si puede actuar como una cadena (es decir, si tiene un método ___str___() que devuelve una cadena).

Por ejemplo, digamos que tenemos foo como un entero, 12

foo = 12

La notación húngara nos dice que deberíamos llamar a ese iFoo o algo así, para denotar que es un número entero, de modo que más adelante sepamos qué es. Excepto en Python, eso no funciona, o mejor dicho, no tiene sentido. En Python, decido qué tipo quiero cuando lo uso. ¿Quiero una cadena? bien si hago algo como esto:

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

Tenga en cuenta el %s - string. Foo no es una cadena, pero el operador % llamará a foo.___str___() y usará el resultado (suponiendo que exista). foo sigue siendo un número entero, pero lo tratamos como una cadena si queremos una cadena. Si queremos un flotador, entonces lo tratamos como un flotador. En lenguajes tipados dinámicamente como Python, la notación húngara no tiene sentido, porque no importa de qué tipo es algo hasta que lo use, y si necesita un tipo específico, entonces simplemente asegúrese de convertirlo a ese tipo (por ejemplo, float(foo) ) cuando lo usas.

Tenga en cuenta que los lenguajes dinámicos como PHP no tienen este beneficio: PHP intenta hacer ''lo correcto'' en segundo plano basándose en un oscuro conjunto de reglas que casi nadie ha memorizado, lo que a menudo resulta en desastres catastróficos inesperadamente. En este caso, algún tipo de mecanismo de nomenclatura, como $files_count o $file_name $files_count , puede ser útil.

En mi opinión, la notación húngara es como sanguijuelas. Tal vez en el pasado fueron útiles, o al menos parecían útiles, pero hoy en día es solo una gran cantidad de tipeo extra para no obtener muchos beneficios.

Creo que agolpa masivamente el código fuente.

Tampoco le gana mucho en un lenguaje fuertemente tipado. Si realiza alguna forma de confusión de tipos, el compilador le informará al respecto.

El IDE debe impartir esa información útil. El húngaro podría haber hecho algún tipo (no mucho, pero algo) de sentido cuando los IDE estaban mucho menos avanzados.

El artículo de Joel es genial, pero parece omitir un punto importante:

Húngaro hace que una ''idea'' particular (tipo + nombre identificador) sea única, o casi única, en toda la base de código, incluso una base de código muy grande.

Eso es enorme para el mantenimiento del código. Significa que puede usar una buena búsqueda de texto de una sola línea (grep, findstr, ''buscar en todos los archivos'') para encontrar CADA mención de esa ''idea''.

¿Por qué es tan importante cuando tenemos IDE que saben cómo leer el código? Porque aún no son muy buenos para eso. Esto es difícil de ver en una pequeña base de código, pero obvia en una grande, cuando la ''idea'' se puede mencionar en comentarios, archivos XML, scripts de Perl y también en lugares fuera del control de fuente (documentos, wikis, bases de datos de errores).

Debe tener un poco de cuidado incluso aquí; por ejemplo, pegar token en macros C / C ++ puede ocultar menciones del identificador. Dichos casos se pueden tratar utilizando convenciones de codificación, y de todos modos tienden a afectar solo a una minoría de los identificadores en la base de código.

PD Hasta el punto sobre el uso del sistema tipo vs. húngaro: lo mejor es usar ambos. Solo necesita un código incorrecto para que se vea mal si el compilador no lo detecta. Hay muchos casos en los que es inviable hacer que el compilador lo atrape. Pero donde es factible, sí, ¡por favor hazlo!

Sin embargo, al considerar la viabilidad, considere los efectos negativos de los tipos divididos. por ejemplo, en C #, envolver ''int'' con un tipo no incorporado tiene enormes consecuencias. Entonces tiene sentido en algunas situaciones, pero no en todas.

En Joel Spolsky''s Making Wrong Code Look Wrong , explica que lo que todo el mundo considera Notación Húngara (que él llama Sistemas Húngaros) no es lo que realmente pretendía ser (lo que él llama Apps Húngaro). Desplácese hasta el encabezado I''m Hungary para ver esta discusión.

Básicamente, Systems Hungarian no vale nada. Simplemente le dice lo mismo que su compilador y / o IDE le dirá.

Las aplicaciones húngaras le dicen qué se supone que significa la variable, y en realidad pueden ser útiles.

Es increíblemente redundante e inútil es la mayoría de los IDEs modernos, donde hacen un buen trabajo al hacer que el tipo sea aparente.

Además, para mí, es molesto ver intI, strUserName, etc. :)

Es una convención útil para nombrar controles en un formulario (btnOK, txtLastName, etc.), si la lista de controles aparece en una lista desplegable alfabética en su IDE.

Joel Spolsky escribió una buena publicación en el blog sobre esto. http://www.joelonsoftware.com/articles/Wrong.html Básicamente se trata de no hacer su código más difícil de leer cuando un IDE decente le dirá que quiere escribir la variable si no puede recordar. Además, si hace que su código sea suficientemente compartimentado, no tiene que recordar qué se declaró una variable como tres páginas.

Joel está equivocado, y aquí está el por qué.

Esa información de "aplicación" de la que está hablando debe estar codificada en el sistema de tipos . No debe depender de cambiar los nombres de las variables para asegurarse de no pasar datos inseguros a las funciones que requieren datos seguros. Debería convertirlo en un error de tipo, por lo que es imposible hacerlo. Cualquier información insegura debe tener un tipo marcado como inseguro, por lo que simplemente no se puede pasar a una función segura. Para convertir de inseguro a seguro se debe procesar con algún tipo de función de desinfección.

Muchas de las cosas de las que Joel habla como "tipos" no son clases; son, de hecho, tipos.

Sin embargo, lo que falta en la mayoría de los lenguajes es un sistema tipográfico que es lo suficientemente expresivo como para imponer este tipo de distinciones. Por ejemplo, si C tuviera una especie de "tipo fuerte def" (donde el nombre typedef tenía todas las operaciones del tipo base, pero no era convertible), muchos de estos problemas desaparecerían. Por ejemplo, si pudieras decir, strong typedef std::string unsafe_string; para introducir un nuevo tipo de unsafe_string no unsafe_string que no se podría convertir a una cadena unsafe_string (y así podría participar en la resolución de sobrecarga, etc.), entonces no necesitaríamos prefijos tontos.

Entonces, la afirmación central de que el húngaro es para cosas que no son tipos está mal. Se está utilizando para obtener información tipográfica. Más información de tipo que la información tradicional de tipo C, sin duda; es información de tipo que codifica algún tipo de detalle semántico para indicar el propósito de los objetos. Pero sigue siendo información de tipo, y la solución adecuada siempre ha sido codificarla en el sistema de tipos. Codificarlo en el sistema de tipos es, de lejos, la mejor manera de obtener una validación y aplicación adecuadas de las reglas. Los nombres de las variables simplemente no cortan la mostaza.

En otras palabras, el objetivo no debe ser "hacer que el código incorrecto se vea mal para el desarrollador". Debería ser "hacer que el código incorrecto se vea mal para el compilador ".

La mayoría de las personas usan la notación húngara de manera incorrecta y obtienen resultados incorrectos.

Lea este excelente artículo de Joel Spolsky: Hacer que el código incorrecto se vea mal .

En resumen, la notación húngara donde prefijas tus nombres de variable con su type (cadena) (sistemas húngaros) es mala porque es inútil.

La notación húngara, como fue concebida por su autor, donde se prefija el nombre de la variable con su kind (utilizando el ejemplo de Joel: cadena segura o cadena insegura), llamada Aplicaciones, el húngaro tiene sus aplicaciones y sigue siendo valioso.

La notación húngara puede ser útil en idiomas sin comprobación de tipos en tiempo de compilación, ya que permitiría al desarrollador recordar rápidamente cómo se utiliza la variable en particular. No hace nada por el rendimiento o el comportamiento. Se supone que mejora la legibilidad del código y es principalmente una cuestión de gusto y estilo de codificación. Por esta misma razón, es criticado por muchos desarrolladores, no todos tienen el mismo cableado en el cerebro.

Para los lenguajes de comprobación de tipos en tiempo de compilación es casi inútil, al desplazarse unas pocas líneas se debe revelar la declaración y, por lo tanto, escribir. Si las variables globales o su bloque de códigos se extiende por mucho más que una pantalla, tiene graves problemas de diseño y reutilización. Por lo tanto, una de las críticas es que la notación húngara permite a los desarrolladores tener un diseño incorrecto y salirse con la suya fácilmente. Esta es probablemente una de las razones por las que se ha irritado.

Por otro lado, puede haber casos en los que incluso los lenguajes de verificación de tipos en tiempo de compilación se beneficiarían de la notación húngara: punteros vacíos o HANDLE en win32 API. Esto ofusca el tipo de datos real, y podría ser conveniente utilizar la notación húngara allí. Sin embargo, si uno puede saber el tipo de datos en tiempo de compilación, ¿por qué no usar el tipo de datos apropiado?

En general, no hay razones difíciles para no utilizar la notación húngara. Es una cuestión de me gusta, políticas y estilo de codificación.

La notación húngara solo tiene sentido en idiomas sin tipos definidos por el usuario . En un lenguaje funcional u OO moderno, codificaría información sobre el "tipo" de valor en el tipo de datos o clase en lugar de en el nombre de la variable.

Varias respuestas hacen referencia al artículo de Joels . Sin embargo, tenga en cuenta que su ejemplo está en VBScript, que no admite clases definidas por el usuario (durante mucho tiempo al menos). En un lenguaje con tipos definidos por el usuario, usted resolvería el mismo problema creando un HtmlEncodedString-type y luego dejaría que el método Write lo acepte solo. En un lenguaje estáticamente tipado, el compilador detectará cualquier error de codificación; de forma dinámica, obtendrá una excepción de tiempo de ejecución, pero en cualquier caso está protegido contra la escritura de cadenas no codificadas. Las notaciones húngaras solo convierten al programador en un verificador de tipos humano, y es el tipo de trabajo que normalmente es mejor manejado por el software.

Joel distingue entre "sistemas húngaros" y "aplicaciones húngaras", donde "sistemas húngaros" codifica los tipos incorporados como int, float, etc., y "aplicaciones húngaras" codifica "tipos", que es metainformación de alto nivel sobre variables más allá del tipo de máquina, en un OO o lenguaje funcional moderno puede crear tipos definidos por el usuario, por lo que no hay distinción entre tipo y "tipo" en este sentido, ambos pueden representarse mediante el sistema de tipo, y "aplicaciones" El húngaro es tan redundante como el "sistema" húngaro.

Entonces, para responder a su pregunta: los sistemas húngaros solo serían útiles en un lenguaje inseguro y débilmente tipeado, por ejemplo, asignar un valor flotante a una variable int hará que el sistema falle. La notación húngara se inventó específicamente en los años sesenta para su uso en BCPL , un lenguaje de bajo nivel que no hacía ningún tipo de comprobación. No creo que ningún lenguaje de uso general hoy tenga este problema, pero la notación vivió como una especie de programación de culto a la carga .

Las aplicaciones húngaras tendrán sentido si está trabajando con un idioma sin tipos definidos por el usuario, como VBScript heredado o versiones anteriores de VB. Tal vez también las primeras versiones de Perl y PHP. De nuevo, usarlo en un lenguaje moderno es puro culto a la carga.

En cualquier otro idioma, húngaro es simplemente feo, redundante y frágil. Repite información ya conocida del sistema de tipos, y no debe repetirse . Use un nombre descriptivo para la variable que describe la intención de esta instancia específica del tipo. Utilice el sistema de tipos para codificar invariantes y metainformación sobre "tipos" o "clases" de variables, es decir. tipos.

El punto general del artículo de Joels - que el código incorrecto se vea mal - es un muy buen principio. Sin embargo, una protección aún mejor contra los errores es, cuando sea posible, tener código incorrecto para ser detectado automáticamente por el compilador.

No hay ninguna razón por la cual no se debe hacer un uso correcto de la notación húngara. Su impopularidad se debe a un back-lah de larga duración en contra del mal uso de la notación húngara, especialmente en las API de Windows.

En los viejos tiempos, antes de que existiera algo parecido a un IDE para DOS (lo más probable es que no tuviera suficiente memoria libre para ejecutar el compilador en Windows, por lo que su desarrollo se realizó en DOS), no recibió ninguna ayuda de al pasar el mouse sobre un nombre de variable. (Suponiendo que tenía un mouse). ¿Qué tuvo que hacer con las funciones de devolución de eventos en las que todo se le pasó como un int de 16 bits (WORD) o int de 32 bits (LONG WORD)? Luego tuvo que convertir esos parámetros a los tipos apropiados para el tipo de evento dado. En efecto, gran parte de la API era prácticamente sin tipo.

El resultado, una API con nombres de parámetros como estos:

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

Tenga en cuenta que los nombres wParam y lParam, aunque bastante horribles, en realidad no son peores que nombrarlos param1 y param2.

Para empeorar las cosas, Window 3.0 / 3.1 tenía dos tipos de punteros, cercano y lejano. Entonces, por ejemplo, el valor de retorno de la función de administración de memoria LocalLock era un PVOID, pero el valor de retorno de GlobalLock era un LPVOID (con la ''L'' por tiempo). Esa notación horrible luego se extendió de modo que una cadena de l ong p ointer estaba precedida por lp , para distinguirla de una cadena que simplemente había sido malloc''d.

No es de sorprender que hubo una reacción en contra de este tipo de cosas.

Olvidas la razón número uno para incluir esta información. No tiene nada que ver contigo, el programador. Tiene todo que ver con la persona que viene por el camino 2 o 3 años después de salir de la compañía que tiene que leer esas cosas.

Sí, un IDE identificará rápidamente los tipos por usted. Sin embargo, cuando está leyendo algunos lotes largos de código de ''reglas de negocios'', es bueno no tener que detenerse en cada variable para averiguar de qué tipo es. Cuando veo cosas como strUserID, intProduct o guiProductID, hace que el tiempo de aceleración sea mucho más fácil.

Estoy de acuerdo en que MS fue demasiado lejos con algunas de sus convenciones de nomenclatura, clasifico eso en la pila de "demasiado de una buena cosa".

Las convenciones de nomenclatura son buenas, siempre y cuando se apeguen a ellas. He revisado el código antiguo suficiente que me obligaba a revisar constantemente las definiciones de tantas variables con nombres similares que presiono "camel-casing" (como se llamaba en un trabajo anterior). En este momento estoy en un trabajo que tiene miles de líneas de código ASP clásico completamente descompuesto con VBScript y es una pesadilla tratar de resolver las cosas.

Siempre he pensado que un prefijo o dos en el lugar correcto no dolería. Creo que si puedo impartir algo útil, como "Oye, esta es una interfaz, no cuentes con un comportamiento específico" allí mismo, como en IEnumerable, debería hacerlo. Los comentarios pueden desordenar las cosas mucho más que solo un símbolo de uno o dos caracteres.

Siempre utilizo la notación húngara para todos mis proyectos. Encuentro realmente útil cuando trato con cientos de nombres de identificadores diferentes.

Por ejemplo, cuando llamo a una función que requiere una cadena, puedo escribir ''s'' y presionar control-espacio y mi IDE me mostrará exactamente los nombres de las variables con el prefijo ''s''.

Otra ventaja, cuando prefijo u para unsigned y para firmts firmados, veo inmediatamente dónde estoy mezclando firmado y sin firmar de maneras potencialmente peligrosas.

No puedo recordar la cantidad de veces que en una gran base de código de 75000 líneas, los errores fueron causados ​​(por mí y por otros también) debido al nombre de variables locales al igual que las variables miembro existentes de esa clase. Desde entonces, siempre prefijo miembros con ''m_''

Es una cuestión de gusto y experiencia. No lo golpees hasta que lo hayas probado.

Soy mi experiencia, es malo porque:

1 - luego rompes todo el código si necesitas cambiar el tipo de una variable (es decir, si necesitas extender un entero de 32 bits a un entero de 64 bits);

2 - esta es información inútil ya que el tipo ya está en la declaración o utiliza un lenguaje dinámico donde el tipo real no debería ser tan importante en primer lugar.

Además, con un lenguaje que acepta programación genérica (es decir, funciones donde el tipo de algunas variables no se determina al escribir la función) o con sistema de tipeo dinámico (es decir, cuando el tipo ni siquiera es determinante en tiempo de compilación), ¿cómo nombraría su variables? Y la mayoría de los idiomas modernos son compatibles con uno u otro, incluso si se trata de una forma restringida.

Tachar caracteres crípticos al comienzo de cada nombre de variable es innecesario y muestra que el nombre de la variable en sí mismo no es lo suficientemente descriptivo. La mayoría de los idiomas requieren el tipo de variable en la declaración de todos modos, por lo que la información ya está disponible.

También existe la situación en la que, durante el mantenimiento, un tipo de variable debe cambiar. Ejemplo: si una variable declarada como "uint_16 u16foo" necesita convertirse en un unsigned de 64 bits, ocurrirá una de dos cosas:

  1. Revisará y cambiará cada nombre de variable (asegurándose de no manguera ninguna variable no relacionada con el mismo nombre), o
  2. Simplemente cambie el tipo y no cambie el nombre, lo que solo causará confusión.

Tiendo a utilizar la notación húngara solo con los controles del servidor ASP.NET, de lo contrario, me parece demasiado difícil determinar qué controles son qué en el formulario.

Toma este fragmento de código:

<asp:Label ID="lblFirstName" runat="server" Text="First Name" /> <asp:TextBox ID="txtFirstName" runat="server" /> <asp:RequiredFieldValidator ID="rfvFirstName" runat="server" ... />

Si alguien puede mostrar una mejor manera de tener ese conjunto de nombres de control sin húngaro, estaría tentado de moverme hacia él.

vUtilizar la nnotación adjunta Nominal vmakes nreading ncode adjdifficult.

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

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.

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 compiler 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. :)

Several reasons:

  • 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 ).

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.

Entonces, básicamente, no rechazo esta notación como un todo, sino que tomé lo que parece apropiado para mis necesidades.
Y, por supuesto, cuando contribuyo a algún proyecto (trabajo, código abierto), ¡simplemente uso las convenciones en su lugar!