User:DLuebbert/sandbox


 * Apps Hungarian predates the systems variant by a number of years, and was introduced to the Microsoft Systems Division by migrant developers who previously worked in the Applications Division.


 * In chronological order, the Apps idiom was used to develop the entire corpus of source code for Microsoft Multiplan, Word, Chart, File, Excel, Works, Access and most of the shared code written for the Microsoft Office suite, which was abstracted from the separate implementation of similar functions, mostly user interface, file system, spell check and grammar check  functionality.


 * Those redundant application parts shipped separately as parts of the original releases of the constituent Office applications. These were later re-implemented as libraries that were shared by the Office apps, after it became clear that Office as a suite of applications marketed as a unit was going to be a marketplace success.


 * Apps Hungarian notation was also used in the development of all of the compilers, p-code interpreters and software tools that Apps Division wrote for itself to produce the shipping and test versions of their applications.


 * By the time the systems variant became known to the outside world, the original apps variant had been used to notate close to a million lines of the source code of the application programs that the Microsoft Applications division had shipped up to that point.


 * After the bifurcation of the systems hungarian idiom from the Apps Hungarian occurred, tens of millions more lines of source code were written using the original Apps idiom.


 * Apps Hungarian was embedded in the entire fabric of those listed applications. It was not possible to even conceive of "converting" code written in the Apps variant into the Systems variant. That would have required Herculean work that would have produced no user or development benefit, and indeed would have been a self-defeating course of action to undertake that would have led to nearly instant failure of future development efforts by the Applications Division.


 * It would have also been a disaster for Applications Division to do this conversion because that would have required that incredible amounts of application development knowledge be purged from projects, which was already concisely and compactly recorded in the Apps source code during app development, since the Apps Hungarian notation idiom was used to name the data objects and procedures of that code.


 * We would have then had to re-express and re-record all of that information in a much less compact and less comprehensible form.


 * Apps Hungarian was the lingua franca that allowed us to discuss and easily master the mass of code that we maintained for our applications development. Forbidding its use would have led to the confounding disasters similar to those that the Bible report befell mankind after the Lord scrambled human speech to punish the hubris of the erection of the Tower of Babel.


 * I would grant that it is correct to say that Hungarian names were not 'obviously pronounceable'. Despite that, Apps Hungarian practitioners found that it was pretty easy to pronounce Hungarian names if a few rules were followed.


 * Microsoft Applications developers would have failed monumentally as software developers if there was not an efficient way to communicate via Hungarian.


 * As it was, Microsoft Apps Division could compete successfully with staffs of 10 to 15 developers against its competitors, who were already using staffs of hundreds to produce their products (Word Prefect, Lotus and Ashton-Tate). Many thought that the Hungarian notation used in application development allowed Microsoft software engineers to work with that kind of of competitive efficiency.


 * When prefixes of composition were used in a Hungarian name (eg. rg, mp, dn, pl, plc, p, h) we would expand the prefix and name the kind of structure that we were dealing with. An rg was a range (an unstructured array of records), an mp was a map (an array that transformed a meaningful array index into a different datatype), a dn was a domain (an array that stored information corresponding to a particular meaningful type of array coordinate), a pl was a plex (a generalized variable length array), a plc was a plex of character positions (a generalized variable length array whose entries were in one-to-one correspondence with a sorted, searchable array of character positions that marked significant locations within the text stream of a document), a p was a pointer, an h was a handle.


 * If a hungarian tag contained a vowel, we pronounced that tag using the rules of English pronunciation. A SED (a SEction Descriptor) was pronounced like 'said', a PAP (a PAragraph Property block) was pronounced 'pap', like Huckleberry Finn's father's preferred nickname.


 * If a tag did not contain a vowel and was frequently used, if we could, we pronounced it with a vowel sound that fit comfortably within that consonant cluster. A CHP (a CHaracter Property block) we pronounced as a 'chip'. A STSH (a STyle SHeet record) we pronounced as a 'stish'.


 * If a tag was consonantal and two or three characters long, and a vowel didn't automatically suggest itself to make it easier to pronounce, we spelled it out letter by letter.


 * A CP (Character Position in a Word document) we spelled out as a cee-pee. An FC (a File Character position) we spelled out as an eff-cee.


 * If we saw mpdochdod[ ], we pronounced that as map-doc-to-aitch-dod, if the person we were speaking to was an old hand with Word code. If we were speaking to a new programmer who was still learning the lingo, we would say that this array was a map from a DOCument number to a handle that references a heap data block that records a DOcument Descriptor.


 * If we saw hplcbteChp or hplcbtePap, we pronounced that as an aitch-pleece-B-T-E-chip or an aitch-pleece-B-T-E-pap. When we were speaking to neophytes, for their benefit we would read that as a 'handle to a plex of character positions that contains a Bin Table Entry that we use to locate the corresponding CHaracter Prop or PAragraph Prop for a particular Character Position'.


 * If we saw sprm (a Single PRoperty Modifier), we pronounced that as a 'sperm', a numerical opcode that had an operation payload following that specified which single property value in a property block should be changed and described how it should be changed.


 * If we needed to find out the length of a sprmCFBold operator, which sets the bold flag in the CHP (character prop block), we would reference the dnsprm[sprmCFBold].cch, which we would pronounce as the cch (count of characters) value of the sprmCFBoldth entry of the domain of sperms.


 * If we saw a dndl[ ], we would pronounce that as a dee-en-dee-ell, and call it a domain of Display Lines. If we wanted to know the upper left corner coordinates of the 5th line displayed in some window area,

we might reference the pwwd->dndl[5].xpLeft and pwwd->dndl[5].ypTop, which we would pronounce as a 'pee-double u-double u-dee right lump fifth dee-en-dee-el entry's ex-pee-left and why-pee-top'.


 * For a neophyte we'd expand that into "a Pointer to Window Descriptor that points to the domain of display lines for that window (an array that stores info about each line displayed in that window) where we would like to access the 5th entry in that domain corresponding to the 5th line displayed in that window, in order to lookup the xpLeft horizontal pixel coordinate and ypTop vertical pixel coordinate values stored within that entry".


 * I hope that I've demonstrated that apparently unpronounceable Hungarian data object names and procedure names were pronounceable by programmers who had absorbed a particular project's development culture.


 * Those who were versed in the art could pronounce a project's Hungarian names pretty easily a week or two after exposure to the Hungarian usages of a new software project. After that small amount of overhead was paid, our verbal and written communications about our code became much quicker, much more precise, and less confusing, and our code became much easier to comprehend, especially when we were not the code's original author.

DLuebbert (talk) 23:38, 1 January 2013 (UTC)DLuebbert