What is the Hungarian Nomenclature

Naming Rules for Process Model Level 3 Activities

The naming rules for Process Model Level 3 activities include Hungarian Nomenclature, Pascal Nomenclature, and Camelot Nomenclature.

Hungarian Nomenclature: Hungarian nomenclature identifies the scope, type, etc. of a variable by prefixing the variable name with a symbolic identifier in the appropriate lowercase letter. The key to Hungarian nomenclature is that the name of the identifier begins with one or more lowercase letters as a prefix; the prefix is followed by a word or combination of words with an initial capitalized letter, which specifies the purpose of the variable.

Pascal’s nomenclature: Pascal’s nomenclature refers to when variable names and function names are made up of two or more words joined together, with the first letter of each word capitalized. Pascal nomenclature: Pascal nomenclature is used to increase the readability of variables and functions when they are composed of two or more words linked together with the first letter of each word capitalized.

Camel nomenclature: Camel nomenclature is when a variable or function name is linked together by one or more words, and constitute the unique identifier, the first word to start with a lowercase letter; from the second word onwards, the first letter of each word are capitalized.

Contents of a process model

Process: Process management itself should start with a top-level process architecture to form an end-to-end hierarchical process system. Define and design the process management lifecycle methods and standards, and design end-to-end process performance indicators (PPIs). Establishing a central process repository is an important feature to realize process-centric thinking.

People: Process management is a highly specialized task. To realize the process-centric thinking of the organization, the first step is to realize the process management enabler training and the cultivation and development of the process management talent team within the company. The construction of a process learning community and the construction of a process management knowledge exchange mechanism are both important manifestations of this. The certification of process management will better promote the popularization of process-centric thinking among leaders, managers, and ordinary employees, and thus bring about organizational change.

Tools: The application of IT and non-IT management tools plays an important role in the common and realization of process thinking. The establishment of an enterprise-level process management platform, and the process and the enterprise’s strategic objectives, and then effectively associated with the IT system, can effectively realize the organization’s process thinking.

Sub-processes: According to the different industries, based on the value chain combing enterprise process framework, stage process definition, and then sorted by level of combing of combing. Compulsory process execution, sub-processes are not executed, the superior process can not be started.

What’s up with the Microsoft Hungarian nomenclature?

Find a picture

C#: Camel nomenclature and Hungarian nomenclature is what is going on?

I. Hungarian Nomenclature: Widely used in environments like MicrosoftWindows

Hungarian nomenclature identifies the scope, type, etc. of a variable by prefixing the variable name with a symbolic identifier of the appropriate lowercase letter. These symbols can be used more than one at a time, in the order of m_ (member variable), then pointer, then simple data type, then others. For example, m_lpszStr, indicates a long pointer member variable pointing to a string ending in the 0 character.

Two, camel nomenclature:The camel command, as its name suggests, refers to the use of a mixture of upper and lower case letters to form the names of variables and functions. For example, the following is the same function named with camel nomenclature and underscore method respectively: printEmployeePaychecks(); print_employee_paychecks(); the first function name uses camel nomenclature – each of the function name’s logical breakpoints in the function name is labeled with an uppercase letter; the second function name uses the underscore method —- each logical breakpoint in the function name is labeled with an underscore. Camelot nomenclature has become increasingly popular in recent years, and it is used quite a bit in many newer libraries and in environments like Microsoft Windows. On the other hand, underscore nomenclature became popular after the advent of c, and its use is widespread in many older programs and environments such as UNIX.

Programming in the common nomenclature of those

1, Hungarian nomenclature

By adding a lowercase letter before the variable name symbol prefix to identify the variable’s attributes, type, scope and other parameters. Simply put, the “variable name = attribute + type + object description” form.

Example: m_lpszStr, a long pointer member variable pointing to a string ending with



2, camel nomenclature

Also called camel case. Its main specification is that a mixture of upper and lower case letters is used to construct variable names or function names.

Example: printEmployeePaychecks(), as shown in the code, each logical breakpoint of the function is identified with a capital letter

3, Pascal nomenclature

Similar to camel nomenclature, camel nomenclature is the first letter of the lowercase, while Pascal nomenclature requires the first letter of the uppercase. Derived from the naming convention of the


language, it is also known as big-hump nomenclature.

Example: LoginCheck(), string


Opposition to Hungarian Nomenclature

Hungarian nomenclature is a naming convention when programming. Naming conventions are the most important and controversial part of program writing conventions, and have been a point of contention since ancient times. What is the use of naming conventions? In four words: to name the right thing. Using the dichotomy, naming conventions are divided into good naming conventions and bad naming conventions, that is to say, the naming convention of the right name and the naming convention of the wrong name. Good dancing shoes are the ones that make the dancers not feel their presence, and bad dancing shoes are the ones that make the dancers dance in shackles. A bad naming convention has much more destructive power than a good naming convention has creative power.

Some people argue that Hungarian nomenclature is a bad naming convention. An example. Take the example of a static strongly typed programming language, with the analyzed paradigms being C and C++. In the following, Hungarian is short for Hungarian Nomenclature. The benefits of Hungarian nomenclature are ambiguous and unpredictable.

Paradigm 1: strcpy(pstrFoo,pcstrFoo2)Vsstrcpy(foo,foo2)

No programmer will admit that he or she doesn’t know the types of the arguments to the strcpy function, so the gain is zero.

Paradigm 2: unknown_function(nFoo) Vs unknown_function(foo)

The gain is still none. There is a cost to the programmer for not knowing the definitive type of a function that the programmer should go through the documentation for that function. The only benefit of using hun is that the person looking at the code knows that the function asks for an integer parameter, which is of no use. A function is an interface, and the type of the argument is only a small part of the interface. Important information such as what the function does, exit information, thread safety, exception safety, parameter legality, etc. must still be consulted in the documentation.

Paradigm 3: nFoo=nBarVsfoo=bar

The only good thing about using hun is that the person looking at the code knows that a copy action of an integer variable is happening here, and that it sounds okay to rest easy. If he sees nFoo=szBar, there’s no way he can rest easy. But that’s not what happened. It should be the compiler that has the problem in the first place. On the other hand, nFoo=nBar is only syntactically legal; the person looking at the code really cares about semantic legality, and huns don’t help with that. On the other hand, a good writer will consciously follow the rule that one or two temporary variables in the smallest organizational unit of code is appropriate, and that if there are more than three, they should be reorganized. Combined with the first rule, it can be concluded that code that is easy to understand should itself be easy to understand; this is the built-in high quality of the code. Good naming conventions help built-in high quality in a rather limited way, while bad naming conventions hurt built-in high quality more than one might think. Hungarian nomenclature is difficult to implement in C and impossible to implement in C++.

Hungarian nomenclature is a redundancy of the type system, so the key to implementing Hungarian nomenclature is whether or not we can replicate the type system precisely. This depends on the complexity of the type system.


1. Built-in types: int,char,float,double are copied as n,ch,f,d? There doesn’t seem to be any problem. But how should void be represented, hun can’t do it.

2. Combination types: array,union,enum,struct copy as a,u,e,s? is not convenient.

The difficulty here is not naming the main type, but naming the subtype. an for integer arrays?sfoo,sbar for structure foo, structure bar?ausfoo for joint structure foo arrays? Very redundant.

3. Special type: pointer. pointer is theoretically supposed to be a combinatorial type, but it can be considered as a built-in type in C because C doesn’t have a very strict distinction between different pointer types.


1. class: If struct in C can be passed off as a struct, don’t dream of passing off class in C++ as a cls. Strictly speaking, class is not a type at all, but rather a tool for creating types, and the number of types built into the language and the number of user-defined types created by class are not the same as the number of types built into the language. In C++, the number of types built into the language is completely negligible compared to the number of user-defined types created by classes. stdvectorFoo, which represents the standard library vector type variable Foo, is illogical.

2. Namespace: boostfilesystemiteratorFoo, which represents the boost space filesystem subspace traversing the directory type variable Foo, is still infeasible.

3. template: std::map<std::string,std::string> what is the exact name of the type, has exceeded 255 characters.

4. Template parameters: template<classT,classBinaryPredicate>constT&max(constT&a,constT&b,BinaryPredicatecomp) This one comes to use Hungarian nomenclature naming, which is extremely difficult.

5. Type modification: static, extern, mutable, register, volatile, const, short, long, unsigned plus type modification, even more difficult.

Hungarian nomenclature has its advantages but also disadvantages, which need to be used in the use of the strengths and weaknesses, the rational application of it.