| Camelcase |
Articles about Camelcase |
Information AboutCamelcase |
| CATEGORIES ABOUT CAMELCASE | |
| typography | |
| typesetting | |
| naming conventions | |
|
with CamelCase]] CamelCase, '''camel case''' or '''medial capitals''' is the practice of writing Compound Word s or phrases where the words are joined without Space s, and each word is Capitalized within the compound. The name comes from the uppercase "bumps" in the middle of the compound word, suggestive of the Hump s of a Camel . This practice is known by a large variety of names, including BiCapitalization, '''InterCaps''', '''MixedCase''', etc., and many of its users do not ascribe a name to it at all. CamelCase is a standard Identifier Naming Convention for several Programming Language s, and has become fashionable in Marketing for names of products and companies. Outside these contexts, however, CamelCase is rarely used in Formal Written English , and most Style Guide s recommend against it. VARIATIONS AND SYNONYMS There are two common varieties of CamelCase, distinguished by their handling of the initial letter of what would otherwise be the first of separate words. Where the first letter is capitalized is commonly called UpperCamelCase, ''' Pascal Case''', or '''BiCapitalized'''. Where the first letter is left in lowercase is commonly called '''lowerCamelCase'''. This variant has also been occasionally called dromedaryCase or '''camelCase'''. For clarity, this article will use the terms '''UpperCamelCase''' and '''lowerCamelCase''', respectively. camelCaseLooksLikeThis lowerCamelCaseLooksTheSame UpperCamelCaseLooksLikeThis The term '' StudlyCaps '' is similar — but not necessarily identical — to CamelCase. It is sometimes used in reference to CamelCase but can also refer to random mixed capitalization (as in ''"MiXeD CaPitALiZaTioN"'') as popularly used in Online Culture . Other synonyms include:
The name ''CamelCase'' is not related to the "Camel book" ('' Programming Perl ''), which uses all-lowercase identifiers with underscores in its sample code. CODING STANDARDS Internal capitalization is recommended or enforced by many computer systems, and mandated by the Coding Standard s of many programming languages — such as Mesa , the Systems Programming Language of the Xerox Alto (late 1970s), or the modern language Java . It is also the official convention for file names in Java and of the Amiga personal computers. Coding standards often distinguish between UpperCamelCase and lowerCamelCase, typically specifying which variety should be used for specific kinds of entities: Variable s, Record Fields , Method s, Procedures , Types , etc.. For instance, the Java coding style dictates that UpperCamelCase be used for Classes , and lowerCamelCase be used for Instances and Members . The original Hungarian Notation for programming specifies that a lowercase abbreviation for the "usage type" (not data type) should be prefixed on all variable names, with the remainder of the name in UpperCamelCase; as such it is a form of lowerCamelCase. NIEM standards require that XML Data Elements use UpperCamelCase and XML Attributes use lowerCamelCase. Some Wiki s, especially the earlier ones, use CamelCase to mark words that should be automatically linked. In many modern wikis (such Wikipedia and other MediaWiki -based wikis) this convention was abandoned in favor of explicit link markup, e.g. with HISTORY Early uses CamelCase has been sporadically used since ancient times, for example as a traditional spelling style for certain surnames, such as in Scottish names like ''McLean'' ("son of Gilian") and Hiberno-Norman names like Fitz Gerald (originally, "son of Gerald"), or the French ''duPont'' or ''DuPont'' ("of/from the bridge"). In the early 20th century, it was used occasionally for Trademark ing corporations and products, such as the CinemaScope Movie projection system introduced in the 1950s . CamelCase also occurred sometimes in Acronym s like DoD , or technical codes and formulas like HeLa ( 1983 ). CamelCase has been used in languages other than English for a variety or purposes, such as the transcription of Tibetan names like ''rLobsang'', or names of Bantu Languages like '' KiSwahili '' or '' IsiZulu ''. In French , abbreviations such as OuLiPo ( 1960 ) were favored for a time as alternatives to acronyms. However, the use of CamelCase became widespread only in the 1970s or 1980s , when it was adopted as a standard or alternative Naming Convention for multi-word Identifier s in several Programming Language s. There are various possible origins, and it may have developed independently from multiple sources. Two of these theories are exposed below. Background: multi-word identifiers In programs of any significant size, there is a need for descriptive (hence multi-word) Identifier s, like "previous balance" or "end of file". Writing the words together as in "endoffile" is not satisfactory because the names often become unreadable. Therefore, the pioneer programming language COBOL allowed a Hyphen ("-") to be used between words of compound identifiers, as in "END-OF-FILE". The contemporary "algebraic" language Fortran reserved the hyphen as the minus operator, but allowed spaces to be arbitrarily embedded into identifiers, so that "TOTAMP" could be written "TOT AMP" (or "TO TAMP"). (This feature was of little use, however, because most Fortran compilers did not allow identifiers longer than six letters.) The common Punched Card character sets of the time had no lower-case letters and no special character that would be adequate as a word separator in identifiers. However, by the late 1960 s the ASCII character set standard had been established, allowing the designers of the C language to adopt the Underscore character "_" as a word joiner. Underscore-separated compounds like "end_of_file" are still prevalent in C programs and libraries. CamelCase is by no means universal. Users of several modern programming languages, notably those in the Lisp family, nearly always use hyphens. Among the reasons sometimes given are that doing so does not require shifting on most keyboards, and that the words are more readable when they are separated. The "Lazy Programmer" origin One explanation of the origins of CamelCase in Computing claims that the style originated within the culture of C Programmers and Hackers , who found it more convenient than the standard underscore-based style. On most keyboards, the underscore key is inconveniently placed. Additionally, in some fonts the underscore character can be confused with a minus sign; it can be overlooked because it falls below the string of characters, or it can be lost entirely when displayed or printed underlined, or when printed on a Dot-matrix Printer with a defective pin or misaligned ribbon. Moreover, compiler limits on identifier length and the small Computer Display s available in the 1970s worked together to encourage brevity. Many programmers thus chose to use CamelCase for it yielded legible compound names with fewer keystrokes and fewer characters. Hungarian Notation is an extension of this style. The "Paranoid Programmer" origin Programmers working in the tradition of linkage oriented languages, especially the Unix C tradition (and later C++ ), had many concerns to address. Early Unix systems (and early personal computers in general) provided Linkage models where external Identifier s were distinguished to a short length, often as few as the initial eight characters. Many clashes were possible within the external identifier linkage space which potentially commingles code generated by various high level compilers, Runtime libraries required by each of these compilers, compiler generated helper functions, and program startup code, of which some fraction was inevitably compiled from system Assembly Language . Within this Collision Domain the underscore character quickly became entrenched as the primary mechanism for differentiating the external linkage space. It was common practice for C compilers to prepend a leading underscore to all external scope program identifiers to avert clashes with contributions from runtime language support. Furthermore, when the C/C++ compiler needed to introduce names into external linkage as part of the translation process, these names were often distinguished with some combination of multiple leading or trailing underscores. This practice was later codified as part of the C and C++ language standards, in which the use of leading underscores was reserved for the implementation. A second, independent collision domain was the C Preprocessor . The C language preprocessor is unusual in that it does not respect any language-defined Scoping model or reserved Namespace , not even C language Keywords . This problem was generally addressed by writing Macro s in macro case which mostly mixes upper case letters with dividing underscores: #define OPEN_FILE_LIMIT (15) Once again the implementation must often supply hidden macros, and once again dressing these up these "hidden behind the scenes" identifiers with multiple leading or trailing underscores became accepted practice. As this practice became pervasive on both levels, the underscore gained a cognitive association with system level programming, hidden technicalities, and the lowest tranches of language support. The C language linkage model further complicated matters by not supporting a strong module-level linkage model. In the C language the concept of ''module'' was initially rather loose. There was no language distinction between function names intended for linkage to other compilation units and function names intended only for use within a single compilation unit to simplify the implementation. The C language provides the ''static'' keyword which makes it possible to hide names from external linkage, but this was rarely employed, as it also obscured these names from most runtime debugging tools. A common early convention was to use names (often prosaic) consisting mostly of lower case letters and underscores for names in external linkage not intended for use by other Translation Unit s such as a local function named count_obscure_piddly_flags and camel case or some variant for primary application calls such as EditSaveFile.The "Alto Keyboard" origin Another explanation is that CamelCase started at Xerox PARC around 1978, with the Mesa Programming Language developed for the Xerox Alto computer. This machine lacked an underscore key, and the hyphen and space characters were not permitted in identifiers, leaving CamelCase as the only viable scheme for readable multiword names. The PARC Mesa Language Manual (1979) included a coding standard with specific rules for Upper- and lowerCamelCase which was strictly followed by the Mesa libraries and the Alto operating system. The Smalltalk language, which was developed originally on the Alto and became quite popular in the early 1980s , may have been instrumental in spreading the style outside PARC. CamelCase was also used in the PostScript graphics language, another very popular PARC invention. Further boost was provided by Niklaus Wirth — the inventor of Pascal — who acquired a taste for CamelCase during a sabbatical at PARC, and used it in Modula , his next programming language. Spread to mainstream usage During the same period in which personal computers exposed Hacker Culture to a more mainstream audience in the 1980s and 1990s , CamelCase became Fashion able for corporate Trade Name s, first in computer-related fields but later expanding further into the mainstream. During the Dot-com Boom of in the late 1990s , in particular, the lowercase prefixes "e" (for " Electronic ") and "i" (for " Internet ", " Information ", or perhaps " Intelligent ") became quite common. Here are some examples ranging from the 1960s to the 2000s , sorted by year:
This fashion has become so pervasive that it is often incorrectly applied to names that do not use it officially, as in '' TransAmerica '' (Transamerica), '' FireFox '' (Firefox), '' UseNet (Usenet)'', '' TimeWarner '' (Time Warner, whose new logo does appear in CamelCase fashion), '' GameBoy '' (Game Boy), '' MicroSoft '' (Microsoft) and '' KarmelKorn '' (Karmelkorn). History of the name The original name of the practice, used in Media Studies , Grammar s, and the '' Oxford English Dictionary '', was "medial capitals". The fancier names such as "InterCaps", "CamelCase", and variations thereof are relatively recent, and seem more common in computer-related communities. The earliest known occurrence of ''InterCaps'' on Usenet is in an April 1990 post to the group alt.folklore.computers by . [http://groups.google.com/groups?selm=newton.212.30563F09%40michelob.wustl.edu&output=gplain]. "With the advent of programming languages having these sorts of constructs, the humpiness of the style made me call it HumpyCase at first, before I settled on CamelCase. I had been calling it CamelCase for years," said Newton, [http://sluug.org/~newt/] "The citation above was just the first time I had used the name on USENET." SEE ALSO REFERENCES EXTERNAL LINKS
|
|
|