¿La gente usa las convenciones de Nomenclatura húngaras en el mundo real? [cerrado]

La Convención de Nomenclatura húngara puede ser útil cuando se usa correctamente, desafortunadamente tiende a ser mal utilizada la mayoría de las veces.

Lea el artículo de Joel Spolsky Haciendo que el Código Incorrecto Parezca Incorrecto para una perspectiva y justificación apropiadas.

Esencialmente, la notación húngara basada en tipos, donde las variables tienen el prefijo de información sobre su tipo (por ejemplo, si un objeto es una cadena, un identificador, un int, etc.).) es en su mayoría inútil y generalmente solo añade gastos generales con muy poco beneficio. Esta, lamentablemente, es la notación húngara con la que la mayoría de la gente está familiarizada. Sin embargo, la intención de la notación húngara tal como se prevé es agregar información sobre el "tipo" de datos que contiene la variable. Esto le permite particionar tipos de datos de otros tipos de datos que no se debe permitir que se mezclen, excepto, posiblemente, a través de algún proceso de conversión. Por ejemplo, coordenadas basadas en píxeles vs. coordenadas en otras unidades, o entrada de usuario insegura versus datos de fuentes seguras, sucesivamente.

Míralo de esta manera, si te encuentras espeluznando a través del código para encontrar información sobre una variable, entonces probablemente necesites ajustar tu esquema de nombres para contener esa información, esta es la esencia de la convención húngara.

Tenga en cuenta que una alternativa a la notación húngara es usar más clases para mostrar la intención del uso de variables en lugar de depender de tipos primitivos en todas partes. Por ejemplo, en lugar de tener prefijos variables para la entrada de usuario insegura, puede tener una clase de envoltura de cadena simple para la entrada insegura del usuario, y una clase de envoltura separada para datos seguros. Esto tiene la ventaja, en lenguajes fuertemente tipeados, de tener particiones forzadas por el compilador (incluso en lenguajes menos fuertemente tipeados usualmente puede agregar su propio código tripwire) pero agrega una cantidad no insignificante de sobrecarga.

Todavía uso la Notación húngara cuando se trata de elementos de la interfaz de usuario, donde varios elementos de la interfaz de usuario están relacionados con un objeto/valor particular, por ejemplo,

LblFirstName para el objeto label, txtFirstName para el cuadro de texto. Definitivamente no puedo nombrarlos a ambos "FirstName" incluso si eso es la preocupación/responsabilidad de ambos objetos.

¿Cómo se acercan los demás a nombrar elementos de la interfaz de usuario?

No tiene sentido (y distrae), pero es un uso relativamente pesado en mi empresa, al menos para tipos como ints, cadenas, booleanos y dobles.

Cosas como sValue, iCount, dAmount o fAmount, y bFlag están en todas partes.

Érase una vez una buena razón para esta convención. Ahora, es un cáncer.

Creo que la notación húngara es una nota interesante a lo largo del 'camino' hacia un código más legible, y si se hace correctamente, es preferible a no hacerlo.

Al decir eso, sin embargo, prefiero eliminarlo, y en lugar de esto:

int vBox = aBottom * lVerticalSide;

Escribe esto:

int boxVolume = bottomArea * verticalHeight;

Estamos en 2008. ¡Ya no tenemos pantallas de ancho fijo de 80 caracteres!

Además, si está escribiendo nombres de variables que son mucho más largos que eso, debería estar buscando refactorizar objetos o funciones Por cierto.

Lamento seguir con una pregunta, pero ¿el prefijo de interfaces con "I" califica como notación húngara? Si ese es el caso, entonces sí, mucha gente lo está usando en el mundo real. Si no, ignore esto.

Veo la Notación húngara como una forma de eludir la capacidad de nuestras memorias a corto plazo. Según los psicólogos, podemos almacenar aproximadamente 7 más o menos 2 trozos de información. La información adicional añadida al incluir un prefijo nos ayuda al proporcionar más detalles sobre el significado de un identificador, incluso sin otro contexto. En otras palabras, podemos adivinar para qué sirve una variable sin ver cómo se usa o declara. Esto se puede evitar aplicando oo técnicas como encapsulacióny el principio de responsabilidad única.

No sé si esto ha sido estudiado empíricamente o no. Yo hipotetizaría que la cantidad de esfuerzo aumenta dramáticamente cuando tratamos de entender clases con más de nueve variables de instancia o métodos con más de 9 variables locales.

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

• l para local
• a para argumento
• m para el miembro
• g para 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á los cambios de tipo, pero a menudo no detectará el uso incorrecto del alcance, las convenciones de nomenclatura sensatas ayudan aquí.

Cuando veo una discusión en húngaro, me alegra ver a la gente pensando mucho sobre cómo hacer que su código sea más claro y cómo hacer que los errores sean más visibles. Eso es exactamente lo que todos deberíamos estar haciendo!

Pero no olvides que tienes algunas herramientas poderosas a tu disposición además de nombrar.

Extract Method Si sus métodos son tan largos que sus declaraciones de variables se han desplazado desde la parte superior de la pantalla, considere hacer que sus métodos sean más pequeños. (Si tiene demasiados métodos, considere una nueva clase.)

Si encuentra que está tomando código postals almacenados en una variable entera y asignándolos a una variable entera tamaño de zapato, considere hacer una clase para los códigos postales y una clase para el tamaño de zapato. Entonces su error será capturado en tiempo de compilación, en lugar de requerir una inspección cuidadosa por parte de un humano. Cuando hago esto, por lo general me encuentro con un montón de código postal - y la lógica del tamaño del zapato-específico que he salpicado alrededor de mi código, que luego puedo mudarme a mis nuevas clases. De repente todo mi código se vuelve más claro, más simple y protegido de ciertas clases de errores. Wow.

Para resumir: sí, piensa bien en cómo usas los nombres en el código para expresar tus ideas claramente, pero también mira a las otras poderosas herramientas de OO a las que puedes recurrir.

No uso un sentido muy estricto de la notación húngara, pero me encuentro usándola ahorrando algunos objetos personalizados comunes para ayudar a identificarlos, y también tiendo a anteponer los objetos de control gui con el tipo de control que son. Por ejemplo, labelFirstName, textFirstName, y buttonSubmit.

He estado trabajando para IBM durante los últimos 6 meses y no lo he visto en ningún lugar (gracias a Dios porque lo odio.) Veo camelCase o c_style.

thisMethodIsPrettyCool()
this_method_is_pretty_cool()

Uso nombres húngaros para elementos de la interfaz de usuario como botones, cuadros de texto y etiquetas. El principal beneficio es la agrupación en la ventana emergente Intellisense de Visual Studio. Si quiero acceder a mis etiquetas, simplemente empiezo a escribir lbl.... y Visual Studio sugerirá todas mis etiquetas, Nicley agrupadas.

Sin embargo, después de hacer más y más cosas de Silverlight y WPF, aprovechando el enlace de datos, ya ni siquiera nombro todos mis controles, ya que no tengo que hacer referencia a ellos desde el código detrás (ya que realmente hay ya no hay ningún código detrás;)

Lo que está mal es mezclar estándares.

Lo correcto es asegurarse de que todos hagan lo mismo.

int Box = iBottom * nVerticleSide

El prefijo original estaba destinado a ser se utiliza para detectar problemas en ecuaciones, pero de alguna manera se ha convertido en hacer el código un poco más fácil de leer desde no tienes que ir a buscar el declaración de variables. Con los días de hoy editores inteligentes donde usted puede simplemente coloca el cursor sobre cualquier variable para encontrar tipo completo, y no solo un abreviatura de la misma, este tipo de la notación húngara ha perdido mucho su significado.

Estoy rompiendo el hábito un poco pero el prefijo con el tipo puede ser útil en JavaScript que no tiene una tipificación de variables fuerte.

Cuando utilizo un lenguaje dinámicamente escrito, ocasionalmente uso Aplicaciones húngaras. Para lenguajes estáticamente tipeados no lo hago. Vea mi explicación en el otro hilo.

La notación húngara no tiene sentido en lenguajes seguros. por ejemplo, un prefijo común que verá en el código antiguo de Microsoft es "lpsz", que significa "puntero largo a una cadena terminada en cero". Desde principios de la década de 1700 no hemos utilizado arquitecturas segmentadas donde existen punteros cortos y largos, la representación normal de cadenas en C++ siempre tiene terminación cero, y el compilador es seguro de tipo, por lo que no nos permitirá aplicar operaciones sin cadena a la cadena. Por lo tanto, ninguna de esta información es de utilidad real para un programador-es solo más escribir.

Sin embargo, yo uso una idea similar: prefijos que aclaran el uso de una variable. Los principales son:

• m = miembro
• c = const
• s = estático
• v = volátil
• p = puntero (y pp=puntero a puntero, etc.)
• i = índice o iterador

Estos se pueden combinar, por lo que una variable miembro estática que es un puntero sería "mspName".

Dónde están estos útil?

• Cuando el uso es importante, es una buena idea recordar constantemente al programador que una variable es (por ejemplo) un volátil o un puntero
• La desreferenciación de puntero solía hacer mi cabeza hasta que usé el prefijo p. Ahora es muy fácil saber cuando se tiene un objeto (Naranja) un puntero a un objeto (pOrange) o un puntero a un puntero a un objeto (ppOrange). Para desreferenciar un objeto, simplemente ponga un asterisco delante de él para cada p en su nombre. Caso resuelto, no más deref ¡bichos!
• En los constructores normalmente encuentro que un nombre de parámetro es idéntico al nombre de una variable miembro (por ejemplo, size). Prefiero usar " mSize = size; "que" size = TheSize "o" this.size = tamaño". También es mucho más seguro: no uso accidentalmente " size = 1 "(configurando el parámetro) cuando quise decir" mSize = 1 " (configurando el miembro)
• En los bucles, mis variables iteradoras son todos nombres significativos. La mayoría de los programadores usan "i" o "index" y luego tienen que inventar nuevos nombres sin sentido ("j", "index2") cuando quieren un bucle interno. Uso un nombre significativo con un prefijo i (iHospital, iWard, iPatient) para saber siempre lo que un iterador está iterando.
• En bucles, puede mezclar varias variables relacionadas usando el mismo nombre base con diferentes prefijos: Orange orange = pOrange[iOrange]; Esto también significa que no comete errores de indexación de matrices (pApple[i] se ve bien, pero escríbalo como pApple[iOrange] y el error es inmediatamente obvio).
• Muchos programadores usarán mi sistema sin saberlo: al agregar un sufijo largo como "Index" o "Ptr", no hay ninguna buena razón para usar una forma más larga que un solo carácter en mi humilde opinión, por lo que uso" i "y"p". Menos tipeo, más consistente, más fácil de leer.

Este es un sistema simple que agrega información significativa y útil al código, y elimina la posibilidad de muchos errores de programación simples pero comunes.

Depende de su lenguaje y entorno. Como regla general, no lo usaría, a menos que el entorno de desarrollo en el que se encuentra haga difícil encontrar el tipo de la variable.

También hay dos tipos diferentes de notación húngara. Ver el artículo de Joel. No puedo encontrarlo (sus nombres no los hacen exactamente fáciles de encontrar), ¿alguien tiene un enlace al que quiero decir?

Edit: Wedge tiene el artículo que quiero decir en su post.

Forma original (La Notación húngara derecha :) ) donde prefijo significa tipo (es decir, longitud, cantidad) de valor almacenado por variable está bien, pero no es necesario en todo tipo de aplicaciones.

La forma popular (La Notación húngara Incorrecta) donde prefijo significa tipo (String, int) es inútil en la mayoría de los lenguajes de programación modernos.

Especialmente con nombres sin sentido como strA. No puedo entender que la gente use nombres sin sentido con prefijos largos que no dan nada.

Utilizo type based (Systems HN) para los componentes (por ejemplo, editFirstName, lblStatus, etc.), ya que hace que el autocompletado funcione mejor.

A veces uso App HN para variables donde la información de tipo es suficiente. Ie fpX indica una variable apuntada fija (tipo int, pero no se puede mezclar y emparejar con un int), rawInput para cadenas de usuario que no han sido validadas etc

Al ser un programador de PHP donde se escribe muy libremente, no hago un punto para usarlo. Sin embargo, yo ocasionalmente identificar algo como una matriz o un objeto dependiendo del tamaño del sistema y el alcance de la variable.