Hungarian Notation - Advantages

Advantages

(Some of these apply to Systems Hungarian only.)

Supporters argue that the benefits of Hungarian Notation include:

• The variable type can be seen from its name. (This is particularly useful when looking at the code outside an integrated development environment - like on a printout).
• The type of value returned by a function is determined without lookup (i.e. searching for function definitions in other files, e.g. ".h" header files, etc.)
• The formatting of variable names may simplify some aspects of code refactoring (while making some aspects more error-prone).
• Multiple variables with similar semantics can be used in a block of code: dwWidth, iWidth, fWidth, dWidth
• Variable names can be easy to remember from knowing just their types.
• It leads to more consistent variable names
• Inappropriate type casting and operations using incompatible types can be detected easily while reading code
• Useful with string-based languages where numerics are strings (Tcl for example)
• In Apps Hungarian, the variable name guards against using it in an improper operation with the same data type by making the error obvious as in:

heightWindow = window.getWidth

• When programming in a language that uses dynamic typing or that is completely untyped, the decorations that refer to types cease to be redundant. Such languages typically do not include declarations of types (or make them optional), so the only sources of what types are allowed are the names themselves, documentation such as comments, and by reading the code to understand what it does. In these languages, including an indication of the type of a variable may aid the programmer. As mentioned above, Hungarian Notation expanded in such a language (BCPL).
• In complex programs with lots of global objects (VB/Delphi Forms), having a basic prefix notation can ease the work of finding the component inside of the editor. Typing btn and pressing causes the editor to pop up a list of Button objects.
• Applying Hungarian notation in a narrower way, such as applying only for member variables helps avoiding naming collision.