• Hungarian Notation
• Object Hungarian Notation Naming Conventions for VB
• From Win98 Developers Handbook
• More VB stuff
• From some unknown web page
• Recommended for Delphi

Hungarian Notation

Program Identifier Naming Conventions

This monograph is intended to give you the flavor of the major ideas behind the conventions.

When confronted with the need for a new name in a program, a good programmer will generally consider the following factors to reach a decision:

1. Mnemonic value—so that the programmer can remember the name.
   
   
2. Suggestive value—so that others can read the code.
   
   
3. “Consistency”—this is often viewed as an aesthetic idea, yet it also has to do with the information efficiency of the program text. Roughly speaking, we want similar names for similar quantities.
   
   
4. Speed of the decision—we cannot spend too much time pondering the name of a single quantity, nor is there time for typing and editing extremely long variable names.

All in all, name selection can be a frustrating and time consuming subtask. Often, a name that satisfies some of the above criteria will contradict the others. Maintaining consistency can be especially difficult.

Advantages of the Conventions

The following naming conventions provide a very convenient framework for generating names that satisfy the above criteria. The basic idea is to name all quantities by their types. This simple statement requires considerable elaboration. (What is meant by “types”? What happens if “types” are not unique?) However, once we can agree on the framework, the benefits readily follow. The following are examples:

1. The names will be mnemonic in a very specific sense: If someone remembers the type of a quantity or how it is constructed from other types, the name will be readily apparent.
   
   
2. The names will be suggestive as well: We will be able to map any name into the type of the quantity, hence obtaining information about the shape and the use of the quantity.
   
   
3. The names will be consistent because they will have been produced by the same rules.
   
   
4. The decision on the name will be mechanical, thus speedy.
   
   
5. Expressions in the program can be subjected to consistency checks that are very similar to the “dimension” checks in physics.

Type Calculus

As suggested above, the concept of “type” in this context is determined by the set of operations that can be applied to a quantity. The test for type equivalence is simple: could the same set of operations be meaningfully applied to the quantities in questions? If so, the types are thought to be the same. If there are operations that apply to a quantity in exclusion of others, the type of the quantity is different.

The concept of “operation” is considered quite generally here; “being the subscript of array A” or “being the second parameter of procedure Position” are operations on quantity x (and A or Position as well). The point is that “integers” x and y are not of the same type if Position (x,y) is legal but Position (y,x) is nonsensical. Here we can also sense how the concepts of type and name merge: x is so named because it is an x-coordinate, and it seems that its type is also an x-coordinate. Most programmers probably would have named such a quantity x. In this instance, the conventions merely codify and clarify what has been widespread programming practice.

Note that the above definition of type (which, incidentally, is suggested by languages such as SIMULA and Smalltalk) is a superset of the more common definition, which takes only the quantity’s representation into account. Naturally, if the representations of x and y are different, there will exist some operations that could be applied to x but not y, or the reverse.

Let us not forget that we are talking about conventions that are to be used by humans for the benefit of humans. Capabilities or restrictions of the programming environment are not at issue here. The exact determination of what constitutes a “type” is not critical, either. If a quantity is incorrectly classified, we have a style problem, not a bug.

Naming Rules

My thesis discusses in detail the following specific naming rules:

1. Quantities are named by their type possibly followed by a qualifier. A convenient (and legal) punctuation is recommended to separate the type and qualifier part of a name. (In C, we use a capital initial for the qualifier as in rowFirst: row is the type; First is the qualifier.)
   
   
2. Qualifiers distinguish quantities that are of the same type and that exist within the same naming context. Note that contexts may include the whole system, a block, a procedure, or a data structure (for fields), depending on the programming environment. If one of the “standard qualifiers” is applicable, it should be used. Otherwise, the programmer can choose the qualifier. The choice should be simple to make, because the qualifier needs to be unique only within the type and within the scope—a set that is expected to be small in most cases. In rare instances more than one qualifier may appear in a name. Standard qualifiers and their associated semantics are listed below. An example is worthwhile: rowLast is a type row value; that is, the last element in an interval. The definition of Last states that the interval is “closed”; that is, a loop through the interval should include rowLast as its last value.
   
   
3. Simple types are named by short tags that are chosen by the programmer. The recommendation that the tags be small is startling to many programmers. The essential reason for short tags is to make the implementation of rule 4 realistic. Other reasons are listed below.
   
   
4. Names of constructed types should be constructed from the names of the constituent types. A number of standard schemes for constructing pointer, array, and different types exist. Other constructions may be defined as required. For example, the prefix p is used to construct pointers. prowLast is then the name of a particular pointer to a row type value that defines the end of a closed interval. The standard type constructions are also listed below.

In principle, the conventions can be enriched by new type construction schemes. However, the standard constructions have proved to be sufficient in years of use. It is worth noting that the types for data structures are generally not constructed from the tags of their fields. First of all, constructions with over two components would be unwieldy. More important, the invariant property of data structure, the set of operations in which the constructions participate, seems to be largely independent of the fields of the structure that determine only the representation. We all have had numerous experiences with changes in data structures that left the operations (but not the implementation of the operations) unchanged. Consequently, I recommend the use of a new tag for every new data structure. The tag with some punctuation (upper case initial or all upper case) should also be used as the structure name in the program. New tags should also be used if the constructions accumulate to the point where readability suffers.

In my experience, tags are more difficult to choose than qualifiers. When a new tag is needed, the first impulse is to use a short, descriptive, common, and generic English term as the type name. This is almost always a mistake. One should not preempt the most useful English phrases for the provincial purposes of any given version of a given program. Chances are that the same generic term could be equally applicable to many more types in the same program. How will we know which is the one with the pretty “logical” name, and which have the more arbitrary variants typically obtained by omitting various vowels or by other disfigurement? Also, in communicating with the programmer, how do we distinguish the generic use of the common term from the reserved technical usage? By inflection? In the long run, an acronym that is not an English word may work out the best for tags. Related types may then share some of the letters of the acronym. In speech, the acronym may be spelled out, or a pronounceable nickname may be used. When hearing the special names, the informed listener will know that the special technical meaning should be understood. Generic terms should remain free for generic use.

For example, a color graphics program may have a set of internal values that denote colors. What should one call the manifest value for the color red? The obvious choice (which is “wrong” here) is RED. The problem with RED is that it does not identify its type. Is it a label or a procedure that turns objects RED? Even if we know that it is a constant (because it is spelled all caps, for example), there might be several color-related types. Of which one is RED an instance? If I see a procedure defined as paint (color), may I call it with RED as an argument? Has the word RED been used for any other purpose within the program? So we decide to find a tag for the color type and use the word Red as a qualifier.

Note that the obvious choice for the qualifier is in fact that the “correct” one! This is because the use of qualifiers are not hampered by any of the above difficulties. Qualifiers are not “exclusive” (or rather they are exclusive only within a smaller set), so we essentially need not take into account the possibility of other uses of the term Red. The technical use of the term will be clear to everyone when the qualifier is paired with an obviously technical type tag. Since qualifiers (usually) do not participate in type construction, there is no inherent reason why they would need to be especially short.

Conversely, the tag for the type of the color value should not be “color.” Just consider all the other color-related types that may appear in the graphics program (or in a future variant): hardware encoding of color, color map entry number, absolute pointer to color map entry, color values in alternate color mapping mode, hue-brightness-saturation triples, other color values in external interfaces; printers, plotters, interacting external software, and so on. Furthermore, the tag will have to appear in names with constructed types and qualifiers.

A typical arbitrary choice could be co (pronounced see-oh). Or, if co was already taken, cv, cl, kl, and so on. Note that the mnemonic value of the tags is just about average: not too bad, but not too good either. The conventions cannot help with creating names that are inherently mnemonic. Instead, they identify, compress, and contain those parts of the program that are truly individual, thus arbitrary. The lack of inherent meaning should be compensated by ample comments whenever a new tag is introduced. This is a reasonable suggestion because the number of basic tags remains very small, even in a large system.

In conclusion, the name of our quantity would be coRed, provided that the color type co is properly documented. The value of the name will show later in program segments such as the following:

      if co == coRed then *mpcopx[coRed]+=dx …

At a glance we can see that the variable co is compared with a quantity of its own kind; coRed is also used as a subscript to an array whose domain is of the correct type. Furthermore, as we will see, the color is mapped into a pointer to x, which is de-referenced (by the *operator in this example) to yield an x type value, which is then incremented by a “delta x” type value. Such “dimensional analysis” does not guarantee that the program is completely free from bugs, but it does help to eliminate the most common kinds. It also lends a certain rhythm to the writing of the code: “Let’s see, I have a co in hand and I need an x; do I have a mpcox? No, but there is a mpcopx that will give me a px; *px will get me the x…”

Naming for “Writability”

A good yardstick for choosing a name is to try to imagine that there is an extraordinary reward for two programmers if they can independently come up with the same program text for the same problem. Both programmers know the reward, but cannot otherwise communicate. Such an experiment would be futile, of course, for any sizable problem, but it is a neat goal. The reward of real life is that a program written by someone else, which is identical to what one’s own program would have been, is extremely readable and modifiable. By the proper use of the conventions, the idea can be approached very closely, give or take a relatively few tags and possibly some qualifiers. The leverage of the tags is enormous. If they are communicated, are agreed on beforehand, or come from a common source, the goal becomes reachable and the reward may be reaped. This makes the documentation of the tags all the more important.

An example of such a consideration is the discretionary use of qualifiers in small scopes where a quantity’s type is likely to be unique, for example in small procedures with a few parameters and locals or in data structures which typically have only a few fields. One might prefer to attach a qualifier even to a quantity with a unique type of “writability,” the ability for someone else to come up with the name without hesitation. As many textbooks point out, the “someone else” can be the same programmer sometime in the future revisiting the long-forgotten code.

Conclusion   Do not use qualifiers when not needed, even if they seem valuable.

Naming Rules for Procedures

Unfortunately, the simple notion of qualified typed tags does not work well for procedure names. Some procedures do not take parameters or do not return values. The scopes of procedure names tend to be large. The following set of special rules for procedures has worked quite satisfactorily:

1. Distinguish procedure names from other names by punctuation, for example by always starting with a capital letter (typed tags of other quantities are in lower case). This alleviates the problem caused by the large scope.
   
   
2. Start the name with the tag of the value that is returned, if any.
   
   
3. Express the action of the procedure in one or two words, typically transitive verbs. The words should be punctuated for easy parsing by the reader (a common legal method of punctuation is the use of capital initials for every word).
   
   
4. Append the list of tags of some or all of the formal parameters if it seems appropriate to do so.

The last point is contrary to the earlier remarks on data structure naming. When the parameters to a procedure are changed, typically all uses of the procedure will need to be updated. There is an opportunity during the update to change the name as well. In fact, the name change can serve as a useful check that all occurrences have been found. With data structures, the addition or change of a field will not have an effect on all uses of the changed structure type. Typically, if a procedure has only one or two parameters, the inclusion of the parameter tags will really simplify the choice of procedure name.

Table 1. Some examples for procedure names

The following is a list of standard type constructions. (X and Y stand for arbitrary tags. According to standard punctuation, the actual tags are lowercase.)

Table 2. Standard type constructions

Where it matters, quantities named mp, rg, dn, or grp are actually pointers to the structures described above.

One obvious problem with the constructions is that they make the parsing of the types ambiguous. Is pfc a tag of its own or is it a pointer to an fc? Such questions can be answered only if one is familiar with the specific tags that are used in a program.

The following are standard qualifiers. (The letter X stands for any type tag. Actual type tags are in lowercase.)

Table 3. Standard qualifiers

Table 4. Some common primitive types

The following partial example of an actual symbol table routine illustrates the use of the conventions in a “real life” situation. The purpose of this example is not to make any claims about the code itself, but to show how the conventions can help us learn about the code. In fact, some of the names in this routine are standard.

1   #include “sy.h”
2   extern int *rgwDic;
3   extern int bsyMac;
4   struct SY *PsySz(char sz[])
6      {
7      char *pch;
8      int cch;
9      struct SY *psy, *PsyCreate();
10      int *pbsy;
11      int cwSz;
12      unsigned wHash=0;
13      pch=sz;
14      while (*pch!=0
15         wHash=(wHash<>11+*pch++;
16      cch=pch-sz;
17      pbsy=&rgbsyHash[(wHash&077777)%cwHash];
18      for (; *pbsy!=0; pbsy = &psy->bsyNext)
19         {
20         char *szSy;
21         szSy= (psy=(struct SY*)&rgwDic[*pbsy])->sz;
22         pch=sz;

23         while (*pch==*szSy++)
24            {
25            if (*pch++==0)
26               return (psy);
27            }
28         }
29      cwSz=0;
30      if (cch>=2)
31         cwSz=(cch-2/sizeof(int)+1;
32      *pbsy=(int *)(psy=PsyCreate(cwSY+cwSz))-rgwDic;
33      Zero((int *)psy,cwSY);
34      bltbyte(sz, psy->sz, cch+1);
35      return(psy);
36      }

The tag SY is the only product specific type in this routine. The definition of SY is found in the include file sy.h (fair enough). The type name itself is in all capitals, a common convention.

Line 2—says that there is an array of words, which is called Dic(tionary). Remember that since Dic is a qualifier, it is named traditionally.

Line 3—is the offset pointing beyond the last sy (see b constructor + Mac standard qualifier.) One has to guess at this time that this is used for allocating new sy’s. The “base” of the offset would also have to be guessed to be rgwDic. Actually, the name grpsy would have been better instead of rgwDic, from this local perspective. In the real program, the rgwDic area is used for a number of different purposes, hence the “neutral” name.

Line 4—is a procedure declaration. Procedure returns a pointer to an SY as the result. The parameter must be a zero-terminated string.

Lines 7-12—declare quantities. The usages should be clear from the names. For example, cwSz is the number of words in some string (probably the argument), pbsy is a pointer to an offset of an sy (p constructor + b constructor). The only qualifier used here is in wHash—the hash code.

Line 13—pch will be a pointer to the first character of sz.

Line 16—cch is the count of characters (c constructor) ostensibly, in sz.

Line 17—cwHash is the number of words in the hash table (I would have called it ibsyMax). In a way, the qualifier on rgbsyHash could be omitted, but it helps identify the hash table in external contexts.

Lines 17-18—note the opportunities for dimensional checking:

      pbsy = &rgbsy[…] follows from pX = &rgX[…]
      pbsy =  &psy->bsyNext follows from pX=&pY->X; or pX = &Y.X
      

So even the use of -> instead of . follows from local context. The p on the left hand side signals the need for the & on the right.

Line 20—introduces a new sz, qualified to distinguish it from the argument. The qualifier, very appropriately, is the source of the datum, Sy.

Line 23—given the use of szSy in this line, the name pchSy would have been a little more appropriate. No harm done, however.

Lines 29-31—this strange code has to do with the fact that the declaration of SY includes 2 bytes of sz, so that cwSz is really the number of words in the sz-2 bytes! This should deserve a comment or at least a qualifier M2 (minus 2) or the like. cwSY is the length of the SY structure in words. The all caps qualifier is not strictly standard, but it helps to associate the quantity with the declaration of SY, rather than with any random sy instance.

PsyCreate is a good procedure name; PsyCreateCw would have been even better. In line 32 we can also see an example of dimensional checking: While we have a psy inside the parenthesis, we need a bsy for the left side (*pbsy=bsy!) so we subtract the “base” of the bsy from the psy.

bX + base = pX; hence: bX = pX - base.

In closing, it is evident that the conventions participated in making the code more correct, easier to write, and easier to read. Naming conventions cannot guarantee good code, however; only the skill of the programmer can.

Object Hungarian Notation Naming Conventions for VB

Object                             Prefix                Example
—————————————————————————————————————
Form                               frm                   frmFileOpen
Check box                          chk                   ReadOnly
Combo box                          cbo                   cboEnglish
Data-bound combo box               dbc                   dbcEnglish
Command button                     cmd                   cmdCancel
Data                               dat                   datBiblio
Directory list box                 dir                   dirSource
Drive list box                     drv                   drvTarget
File list box                      fil                   filSource
Frame                              fra                   fraLanguage
Grid                               grd                   grdPrices
Data-bound grid                    dbg                   dbgPrices
Horizontal scroll bar              hsb                   hsbVolume
Image                              img                   imgIcon
Label                              lbl                   lblHelpMessage
Line                               lin                   linVertical
List box                            lst                  lstPolicyCodes
Data-bound list box                dbl                   dblPolicyCode
Menu                               mnu                   mnuFileOpen
OLE container                      ole                   oleObject1
Option button                      opt                   optFrench
Picture box                        pic                   picDiskSpace
Shape                              shp                   shpCircle
Text box                           txt                   txtGetText
Timer                              tmr                   tmrAlarm

Object                             Prefix                Example
————————————————————————————————————
Vertical scroll bar                vsb                   vsbRate
Animation button                   ani                   aniMailBox
bed      Pen                       Bedit                 bedFirstName
Checkbox                           chk                   chkReadOnly
Picture clip                       clp                   clpToolbar
Communications                     com                   comFax
Control                            ctl                   ctrCurrent
Data control                       dat                   datBiblioDirectory
Directory list box                 dir                   dirSource
Common dialog ctrl                 dlg                   dlgFileOpen
Drive list box                     drv                   drvTarget
File list box                      fil                   filSource
Form                               frm                   frmEntry
Frame (3d)                         fra                   fraStyle
Gauge                              gau                   gauStatus
Group push button                  gpb                   gpbChannel
Graph                              gra                   graRevenue
Grid                               grd                   grdPrices
Pen Hedit                          hed                   hedSignature
Horizontalscrollbar                hsb                   hsbVolume
Image                              img                   imgIcon
Pen Ink                            ink                   inkMap
Keyboard key status                key                   keyCaps
Label                              lbl                   lblHelpMessage
Line                               lin                   linVertical
MDI child form                     mdi                   mdiNote
MAPI message                       mpm                   mpmSentMessage
MAPI session                       mps                   mpsSession
MCI                                mci                   mciVideo
Menu                               mnu                   mnuFileOpen
Object                             obj                   objUserTable
Option Button (3d)                 opt                   optRed
Outline control                    out                   outOrgChart
3d Panel                           pnl (3d)              pnlTitleList
Report control                     rpt                   rptQtr1Earnings
Shape controls                     shp                   shpCircle
Spin control                       spn                   spnPages
Timer                              tmr                   tmrAlarm
Vertical scroll bar                vsb                   vsbRate

Database Objects                   Prefix                Example
—————————————————————————————————————
ODBC Database                      db                    dbAccounts
ODBC Dynaset object                dyn                   dynSalesByRegion
Field collection                   fld                   fldCustomer
Field object                       fld                   fldAddress
Form                               frm                   frmNewUser
Index object                       idx                   idxAge
Index collection                   idx                   idxNewAge
Macro                              mcr                   mcrCollectUsers
QueryDef object                    qry                   qrySalesByRegion
Query                              qry                   qrySalesByRegion
Report                             rpt                   rptAnnualSales
Snapshot object                    snp                   snpForecast
Table object                       tbl                   tblCustomer
TableDef object                    tbd                   tbdCustomers

Vendor                         Abbreviation
—————————————————————-
MicroHelp (VBTools)            m
Pioneer Software Q+E Database  p
Crescent Software              c
Sheridan Software              s
Other (miscellaneous)          o

Objects                            Prefix                Example
——————————————————————————————————-
Alarm(Microhelp)                   almm                  almmAlarm
Animate(Microhelp)                 anim                  animAnimate
Callback(Microhelp)                calm                  callback
Combo Box(Pioneer)                 cbop                  cbopComboBox
Combo Box(Sheridan)                cbos                  cbosComboBox
DB_Check(Pioneer)                  chkp                  chkpCheckBox
chart(Microhelp)                   tm                    tmChart
Clock(Microhelp)                   clkm                  clkmClock
Command Button(Microhelp)          cmdm                  cmdmCommandButton
DB_Command(Pioneer)                cmdp                  cmdpCommandButton
Command Button(Group)(Microhelp)   cmgm                  cmgmBtton
Command Button (icon) (Microhelp)  cmim                  cmimCommandButton
CardDeck(Microhelp)                crdm                  crdmCard
Dice(Microhelp)                    dicm                  dicmDice
SSDir(Sheridan)                    dirs                  dirsDirList
SSDrive(Sheridan)                  drvs                  drvsDriveList
File List(Microhelp)               film                  filmFileList
SSFile(Sheridan)                   fils                  filsFileList
Flip(Microhelp)                    flpm                  flpmButton
Form Scroll(Microhelp)             fsrm                  fsrmFormScroll
Gauge(Microhelp)                   gagm                  gagmGauge
Graph(Other)                       gpho                  gphoGraph
Q_Grid(Pioneer)                    grdp                  grdpGrid
Horizontal Scroll Bar(Microhelp)   hsbm                   hsbmScroll
DB_Hscroll(Pioneer)                hsbp                   hsbpScroll
Histo(Microhelp)                   hstm                   hstmHistograph
Invisible(Microhelp)               invm                   invmInvisible
Icon Tag(Microhelp)                itgm                   itgmListBox
Key State(Microhelp                kstm                   kstmKeyState
Label (3d) (Microhelp)             lblm                   lblmLabel
Line(Microhelp)                    linm                   linmLine
DB_List(Pioneer)                   lstp                   lstpListBox
SSList(Sheridan)                   lsts                   lstsListBox
MDI Control(Microhelp)             mdcm                   mdcmMDIChild
SSMenu(Sheridan)                   mnus                   mnusMenu
Marque(Microhelp)                  mrqm                   mrqmMarque
OddPic(Microhelp)                  odpm                   odpmPicture
Picture(Microhelp)                 picm                   picmPicture
DB_Picture(Pioneer)                picp                   picpPicture
Property Vwr(Microhelp)            pvrm                   vrmPropertyViewer
DB_RadioGroup(Group)(Pioneer)      radp                   radqRadioGroup
Slider(Microhelp)                  sldm                   sldmSlider
Spinner(Microhelp)                 spnm                   spnmSpinner
Spreadsheet(Microhelp)             sprm                   sprmSpreadsheet
Stretcher(Microhelp)               strm                   strmStretcher
Screen Saver(Microhelp)            svrm                   svrmSaver
Switcher(Microhelp)                swtm                   swtmSwitcher
Tag(Microhelp)                     tagm                   tagmListBox
Timer(Microhelp)                   tmrm                   tmrmTimer
ToolBar(Microhelp)                 tolm                   tolmToolBar
Tree(Microhelp)                    trem                   tremTree
Input(Microhelp) (Text)            txtm                   inpmText
DB_Text(Microhelp)                 txtp                   txtpText
Vertical Scroll Bar(Microhelp)     vsbm                   vsbmScroll
DB_VScroll(Pioneer)                vsbp                   vsbpScroll

From Win98 Developers Handbook

Using Hungarian notation, variable names begin with one or more lowercase letters that denote the variable type, thus providing an inherent identification. For example, the prefix h is used to identify a handle, as in hWnd or hDlg, referring to window and dialog box handles, respectively. In like fashion, the prefix lpsz identifies a long pointer to a null-terminated (ASCIIZ) string. Table 2.1 summarizes the Hungarian notation conventions.

Table 2.1: Hungarian Notation Conventions

More VB stuff

Object Naming Conventions for Standard Objects

Prefix    Object Type                           Example
———————————————————————————-
ani       Animation button                      aniMailBox
bed       Pen Bedit                             bedFirstName
cbo       Combo box and drop down list box      cboEnglish
chk       Checkbox                              chkReadOnly
clp       Picture clip                          clpToolbar
cmd (3d)  Command button (3D)                   cmdOk (cmd3dOk)
com       Communications                        comFax
ctr       Control (when specific type unknown)  ctrCurrent
dat       Data control                          datBiblio
dir       Directory list box                    dirSource
dlg       Common dialog control                 dlgFileOpen
drv       Drive list box                        drvTarget
fil       File list box                         filSource
frm       Form                                  frmEntry
fra (3d)  Frame (3d)                            fraStyle (fra3dStyle)
gau       Gauge                                 gauStatus
gpb       Group push button                     gpbChannel
gra       Graph                                 graRevenue
grd       Grid                                  grdPrices
hed       Pen Hedit                             hedSignature
hsb       Horizontal scroll bar                 hsbVolume
img       Image                                 imgIcon
ink       Pen Ink                               inkMap
key       Keyboard key status                   keyCaps
lbl       Label                                 lblHelpMessage
lin       Line                                  linVertical
lst       List box                              lstPolicyCodes
mdi       MDI child form                        mdiNote
mpm       MAPI message                          mpmSentMessage
mps       MAPI session                          mpsSession
mci       MCI                                   mciVideo
mnu       Menu                                  mnuFileOpen
opt (3d)  Option Button (3d)                    optRed (opt3dRed)
ole       OLE control                           oleWorksheet
out       Outline control                       outOrgChart
pic       Picture                               picVGA
pnl3d     3d Panel                              pnl3d
rpt       Report control                        rptQtr1Earnings
shp       Shape controls                        shpCircle
spn       Spin control                          spnPages
txt       Text Box                              txtLastName
tmr       Timer                                 tmrAlarm
vsb       Vertical scroll bar                   vsbRate 

Object Naming Convention for Database Objects

Prefix        Object Type          Example
—————————————————————
db            ODBC Database        dbAccounts
ds            ODBC Dynaset object  dsSalesByRegion
fdc           Field collection     fdcCustomer
fd            Field object         fdAddress
ix            Index object         ixAge
ixc           Index collection     ixcNewAge
qd            QueryDef object      qdSalesByRegion
qry (suffix)  Query (see NOTE)     SalesByRegionQry
ss            Snapshot object      ssForecast
tb            Table object         tbCustomer
td            TableDef object      tdCustomers
 

Menu Naming Conventions

Menu Caption Sequence   Menu Handler Name
Help.Contents           mnuHelpContents
File.Open               mnuFileOpen
Format.Character        mnuFormatCharacter
File.Send.Fax           mnuFileSendFax
File.Send.Email         mnuFileSendEmail 

Naming Conventions for Other Controls

Third-party Controls

Prefix    Control Type        Vendor
cmdm      Command Button      MicroHelp 

Variable and Routine Naming

Part          Description                                  Example
—————————————————————————————————————
<prefix>      Describes the use and scope of the variable. iGetRecordNext

<body>        Describes the variable.                      iGetNameFirst
<qualifier>   Denotes a derivative of the variable.        iGetNameLast
<suffix>      The optional Visual Basic type character.    iGetRecordNext% 

Prefix    Converged    Variable Use         Data Type  Suffix
—————————————————————————————————————
b         bln          Boolean              Integer    %
c         cur          Currency - 64 bits   Currency   @
d         dbl          Double - 64 bit      Double     #
                       signed quantity
dt        dat          Date and Time        Variant
e         err          Error
f         sng          Float/Single - 32    Single     !
                       bit signed
                       floating point
h                      Handle               Integer    %
i                      Index                Integer    %
l         lng          Long - 32 bit        Long       &
                       signed quantity
n         int          Number/Counter       Integer    %
s         str          String               String     $
u                      Unsigned - 16 bit    Long       &

                       unsigned quantity
          udt          User-defined type
vnt       vnt          Variant              Variant
a                      Array 

Prefix         Description
g              Global
m              Local to module or form
st             Static variable
(no prefix)    Non-static variable, prefix local to procedure
v              Variable passed by value (local to a routine)
r              Variable passed by reference (local to a routine) 

iSend - Represents a count of the number of messages sent
bSend - A Boolean flag defining the success of the last Send operation
hSend - A Handle to the Comm interface

The Body of Variable and Routine Names

Qualifiers on Variable and Routine Names

Qualifier  Description (follows Body)
—————————————————————————————————————
First      First element of a set.
Last       Last element of a set.
Next       Next element in a set.
Prev       Previous element in a set.
Cur        Current element in a set.
Min        Minimum value in a set.
Max        Maximum value in a set.
Save       Used to preserve another variable that must be reset later.
Tmp        A “scratch” variable whose scope is highly localized within the
           code. The value of a Tmp variable is usually only valid across
           a set of contiguous statements within a single procedure.
Src        Source. Frequently used in comparison and transfer routines.
Dst        Destination. Often used in conjunction with Source. 

User Defined Types

Type CUSTOMER_TYPE
      sName As String
      sState As String * 2
      lID as Long
   End Type 

   Dim custNew as CUSTOMER_TYPE 

Naming Constants

<mnUSER_LIST_MAX   ’ Max entry limit for User list (integer value,
                     ’ local to module)
   gsNEW_LINE        ’ New Line character string (global to entire
                     ’ application) 

Variant Data Type

   Sub ConvertNulls(rvntOrg As Variant, rvntSub As Variant)
      ’ If rvntOrg = Null, replace the Null with rvntSub
      If IsNull(rvntOrg) Then rvntOrg = rvntSub
   End Sub 

   vnt1 = “10.01” : vnt2 = 11 : vnt3 = “11” : vnt4 = “x4”
   vntResult = vnt1 + vnt2  ’ Does vntResult = 21.01 or 10.0111?
   vntResult = vnt2 + vnt1  ’ Does vntResult = 21.01 or 1110.01?
   vntResult = vnt1 + vnt3  ’ Does vntResult = 21.01 or 10.0111?
   vntResult = vnt3 + vnt1  ’ Does vntResult = 21.01 or 1110.01?
   vntResult = vnt2 + vnt4  ’ Does vntResult = 11x4 or ERROR?
   vntResult = vnt3 + vnt4  ’ Does vntResult = 11x4 or ERROR? 

   iVar1 = 5 + val(sVar2)   ’ use this (explicit conversion)
   vntVar1 = 5 + vntVar2    ’ not this (implicit conversion) 

Commenting Your Code

Section    Comment Description
—————————————————————————————————————
Purpose    What the routine does (not how).
Inputs     Each non-obvious parameter on a separate line with
           in-line comments
Assumes    List of each non-obvious external variable, control, open file,
           and so on.
Returns    Explanation of value returned for functions.
Effects    List of each effected external variable, control, file, and
           so on and the affect it has (only if this is not obvious) 

Formatting Your Code

**************************************************************************
‘Purpose:   Locate first occurrence of a specified user in UserList array.
‘Inputs:    rasUserList():  the list of users to be searched
’           rsTargetUser:   the name of the user to search for
‘Returns:   the index of the first occurrence of the rsTargetUser
’           in the rasUserList array. If target user not found, return -1.
‘**************************************************************************

‘VB3Line: Enter the following lines as one line
Function iFindUser (rasUserList() As String, rsTargetUser as String) _
   As Integer
   Dim i As Integer           ’ loop counter
   Dim bFound As Integer      ’ target found flag
   iFindUser = -1
   i = 0
   While i <= Ubound(rasUserList) and Not bFound
      If rasUserList(i) = rsTargetUser Then
         bFound = True
         iFindUser = i
      End If
   Wend
End Function 

Operators

   vntVar1 = “10.01”
   vntVar2 = 11
   vntResult = vntVar1 + vntVar2         ’ vntResult =  21.01
   vntResult = vntVar1 & vntVar2         ’ vntResult = 10.0111 

Scope

Scope             Variable Declared In:            Visibility
—————————————————————————————————————
Procedure-level   Event procedure, sub, or         Visible in the
                  function                         procedure in which
                                                   it is declared
Form-level,       Declarations section of a form   Visible in every
Module-level      or code module (.FRM, .BAS)      procedure in the
                                                   form or code
                                                   module
Global            Declarations section of a code   Always visible
                  module (.BAS, using Global
                  keyword) 

Third-party Controls

Vendor               Abbv
————————————-

MicroHelp (VBTools)  m
Pioneer Software     p
Crescent Software    c
Sheridan Software    s
Other (Misc)         o 

Control         Control     Abbr  Vendor     Example            VBX File
Type            Name                                            Name
—————————————————————————————————————
Alarm           Alarm       almm  MicroHelp  almmAlarm          MHTI200.VBX
Animate         Animate     anim  MicroHelp  animAnimate        MHTI200.VBX
Callback        Callback    calm  MicroHelp  calmCallback       MHAD200.VBX
Combo Box       DB_Combo    cbop  Pioneer    cbopComboBox       QEVBDBF.VBX
Combo Box       SSCombo     cbos  Sheridan   cbosComboBox       SS3D2.VBX
Check Box       DB_Check    chkp  Pioneer    chkpCheckBox       QEVBDBF.VBX
Chart           Chart       chtm  MicroHelp  chtmChart          MHGR200.VBX
Clock           Clock       clkm  MicroHelp  clkmClock          MHTI200.VBX
Button          Command     cmdm  MicroHelp  cmdmCommandButton  MHEN200.VBX
                Button
Button          DB_Command  cmdp  Pioneer    cmdpCommandButton  QEVBDBF.VBX
Button (Group)  Command     cmgm  MicroHelp  cmgmBtton          MHGR200.VBX
                Button
                (multiple)
Button          Command     cmim  MicroHelp  cmimCommandButton  MHEN200.VBX
                Button
                (icon)
CardDeck        CardDeck    crdm  MicroHelp  crdmCard           MHGR200.VBX
Dice            Dice        dicm  MicroHelp  dicmDice           MHGR200.VBX
List Box (Dir)  SSDir       dirs  Sheridan   dirsDirList        SS3D2.VBX
List Box (Drv)  SSDrive     drvs  Sheridan   drvsDriveList      SS3D2.VBX
List Box (File) File List   film  MicroHelp  filmFileList       MHEN200.VBX
List Box (File) SSFile      fils  Sheridan   filsFileList       SS3D2.VBX
Flip            Flip        flpm  MicroHelp  flpmButton         MHEN200.VBX
Scroll Bar      Form Scroll fsrm  MicroHelp  fsrmFormScroll     ???
Gauge           Gauge       gagm  MicroHelp  gagmGauge          MHGR200.VBX
Graph           Graph       gpho  Other      gphoGraph          XYGRAPH.VBX
Grid            Q_Grid      grdp  Pioneer    grdpGrid           QEVBDBF.VBX
Scroll Bar      Horizontal  hsbm  MicroHelp  hsbmScroll         MHEN200.VBX
                Scroll Bar
Scroll Bar      DB_HScroll  hsbp  Pioneer    hsbpScroll         QEVBDBF.VBX
Graph           Histo       hstm  MicroHelp  hstmHistograph     MHGR200.VBX
Invisible       Invisible   invm  MicroHelp  invmInvisible      MHGR200.VBX
List Box        Icon Tag    itgm  MicroHelp  itgmListBox        MHAD200.VBX
Key State       Key State   kstm  MicroHelp  kstmKeyState       MHTI200.VBX
Label           Label (3d)  lblm  MicroHelp  lblmLabel          MHEN200.VBX
Line            Line        linm  MicroHelp  linmLine           MHGR200.VBX
List Box        DB_List     lstp  Pioneer    lstpListBox        QEVBDBF.VBX
List Box        SSList      lsts  Sheridan   lstsListBox        SS3D2.VBX
MDI Child       MDI Control mdcm  MicroHelp  mdcmMDIChild       ???
Menu            SSMenu      mnus  Sheridan   mnusMenu           SS3D3.VBX
Marque          Marque      mrqm  MicroHelp  mrqmMarque         MHTI200.VB
Picture         OddPic      odpm  MicroHelp  odpmPicture        MHGR200.VBX
Picture         Picture     picm  MicroHelp  picmPicture        MHGR200.VBX
Picture         DB_Picture  picp  Pioneer    picpPicture        QEVBDBF.VBX
Property Vwr    Property    pvrm  MicroHelp  pvrmPropertyViewer MHPR200.VBX
                Viewer
Option (Group)  DB_RadioGroup radp Pioneer   radqRadioGroup     QEVBDBF.VBX
Slider          Slider      sldm  MicroHelp  sldmSlider         MHGR200.VBX
Button (Spin)   Spinner     spnm  MicroHelp  spnmSpinner        MHEN200.VBX
Spreadsheet     Spreadsheet sprm  MicroHelp  sprmSpreadsheet    MHAD200.VBX
Picture         Stretcher   strm  MicroHelp  strmStretcher      MHAD200.VBX
Screen Saver    Screen Saver svrm MicroHelp  svrmSaver          MHTI200.VBX
Switcher        Switcher    swtm  MicroHelp  swtmSwitcher       ???
List Box        Tag         tagm  MicroHelp  tagmListBox        MHEN200.VBX
Timer           Timer       tmrm  MicroHelp  tmrmTimer          MHTI200.VBX
ToolBar         ToolBar     tolm  MicroHelp  tolmToolBar        MHAD200.VBX
List Box        Tree        trem  MicroHelp  tremTree           MHEN200.VBX
Input Box       Input (Text) txtm MicroHelp  inpmText           MHEN200.VBX
Input Box       DB_Text     txtp  Pioneer    txtpText           QEVBDBF.VBX
Scroll Bar      Vertical    vsbm  MicroHelp  vsbmScroll         MHEN200.VBX
                Scroll Bar
Scroll Bar      DB_VScroll  vsbp  Pioneer    vsbpScroll         QEVBDBF.VBX 

From some unknown web page

Hungarian Notation

First, a little disclaimer:

If you DO know Hungarian, and notice anything wrong with this guide, please send me mail. Thanks.

What is Hungarian notation?

Variables

Base Types (Tags)

Common Tags

Prefixes (Constructors)

Common Constructors

Examples

Here are some further examples of constructors + tags:

Qualifiers

The use of many variables will fall into the same basic categories, so there are several standard qualifiers:

for (iw = iwFirst; iw <= iwLast; iw++)
    {
    …
    }

for (iw = iwFirst; iw < iwMax; iw++)
    {
    …
    }

Structures and structure members

Structure members should simply be named the same way variables are. Since the context is usually only within the structure itself, name conflicts are less likely, so qualifiers are often not as necessary. If you have multiple instances of a variable type within the structure, you’ll still need the qualifiers, of course (for example, if you’re creating a structure containing name and address string records, you could name them szName and szAddress). If the language does not support seperate contexts for each structure (I think the Microsoft Macro Assembler (MASM) falls into this category, but I haven’t worked with it in a few years), then the structure name is appended to the name of the member as a qualifier. (So the examples given above might be named szNameDbr and szAddressDbr if these fields appeared in the dbr structure.)

Procedures

1. Procedure names are distinguished from variable names by using some punctuation — for example, function names have the first letter capitalized while variable names begin with lowercase letters.
2. If the procedure explicitly returns a value (as opposed to implicitly returning one through a variable argument), then the procedure name will begin with the type of value that is returned.
3. If the procedure is a true function (that is, it operates on its parameters and returns a value with no side-effects), then it is typical to name it XFromYZ…, where X is the type returned and Y, Z, etc., are the types of the parameters. For example, DxFromWnd(hwnd) (or possibly DxFromHwnd(hwnd) if you really want to be specific) could be used for a function that returns the width of a window.
4. If the procedure has side-effects, then follow the type (if any) with a few words that describe what the procedure does. Each word should be capitalized. For example, FTryMove() could be used to indicate a procedure that checks the validity of a move (in a game, for instance), and returns a boolean value (true/false) to indicate if the move is valid.
5. If the procedure operates on an object, the type of the object should be appended to the name. For example, InitFoo(pfoo) could indicate a procedure that initializes a structure foo (or more accurately in this case, a structure foo that the procedure is given a pointer to).

Macros and constants

Labels

Hungarian Notation Reference

• What is Hungarian Notation?
• Type Prefixes
• Standard Qualifiers
• Other Hungarian Naming Conventions
• More Information About Hungarian Notation

• Back to Mark Riedl

What is Hungarian Notation?

Top

• type: the first characters of the identifier specify what type the object is an instance of. This is achieved by adopting part of the name of the type as a prefix on the identifier. The prefix is always entirely lower-case.
• qualifier: the remainder of the name of the identifier describes what the variable is used for. The qualifier portion can be one word or a run-on word. The qualifier begins with a capital to distinguish it from the type prefix.

Example:

String sNameFirst; //s is a prefix for String type
char cLetter; //c is a prefix for the char type
Button butPushMe; //but is a prefix for the Button type

Type Prefixes

Top

Common Type Prefixes

class IMotion {
public:
   virtual void Fly() = 0;
};

class CRocket {
public:
   class XMotion:public IMotion {
   public:
      void Fly();
   } m_xUnknown;
}

class CAirplane {
public:
   class XMotion:public IMotion {
   public:
      void Fly();
   } m_xUnknown;
}

class CThing {
private:
   int m_nSize;
};

Type Prefixes for non-common Types

In many cases, you will have identifiers of non-standard types. In this case, it will not do to borrow prefixes from the list of standard prefixes. Instead, the programmer needs to invent his own and, even more importantly, remain consistent with his own notation. To invent a prefix, abreviate the type name in a short and meaningful fashion. If it is not possible to abbreviate and the type name is not too long, you can just use the type name as a prefix.

The Type Prefix will always be entirely lowercase and should reflect the name of the type by abbreviating it distinctively.

Example:

Button buttonPushMe; //this is okay, but awkward
Button butPushMe; //a better abreviation for the type prefix
Button bPushMe; //BAD: can be mistaken for a Boolean

Standard Qualifiers

Top

The Qualifier portion of the identifier can be anything but should accurately and concisely describe the purpose of the object. There is a set of standard qualifiers for variables used in commonly performed programming tasks.

Other Hungarian Naming Conventions

Top

Identifiers Containing Multiple Words

If the identifier contains multiple words, then the first letter of each word in the name is capitalized.

Example:

int nThisIsAReallyLongIdentifier

If the identifier contains adjectives that describe the purpose of the object, the adjective succeeds the word it describes.

Example:

CString sNameFirst; //first name
int nNumCowsBrown; //number of brown cows

Functions

Functions should start out with a capital letter and no type prefix. It is not unheard of to start a function with a lowercase letter however. Microsoft urges the use of a capital first letter though the Java awt libraries use a lower-case first letter on member functions.

Example:

CString GetName (); //Microsoft C++ standard
String getName (); //Sun Java standard

Macros and constants

Macros and constants should be entirely in capitals.

Example:

#define MAXSIZE 100
const int MAXSIZE = 100;

More Information About Hungarian Notation

Top

The need for a standard

Programmers typically do not name their identifiers randomly; Programmers commonly name their identifiers mnemonically. However, every programmer is unique and one mnemoic identifier name may mean a lot to one person and nothing to another. A convention is merely a codified style of choosing mnemonics.

One important reason for a standard naming convention is to make your code more easily read by other people. Additional information about an object can be coded into its identifier so that someone reading code does not have to frequently refer back to the objects declaration to find out what type it is. Furthermore, if the identifier relates to what the object is used for in the code, then reading code is greatly simplified because the reader does not have to infer it from how it is used.

Origins of Hungarian notation

Charles Simonya, chief architect at Microsoft is the originator of the Hungarian Notation standard, which is used extensively in Microsoft Windows code. Simonya first used the notation in 1972. The notation was refered to as Hungarian originally as a criticism. At first glance, identifiers using Hungarian Notation appear to be gibberish until the pattern is deduced. Friends of Simonya compared Simonya’s notation convention to some obscure foreign language and since Simonya is Hungarian, that was the obscure foreign language refered to.

Since its inception in 1972, Hungarian Notation has been adopted by Xerox, Apple, 3Com, and of course Microsoft.

Recommended for Delphi

0.2 A Recommended Form of Hungarian Notation for Delphi

0.1 Delphi Standard Controls