Acronyms in CamelCase [closed]

Answer 1

There is airbnb JavaScript Style Guide at github with a lot of stars (~57.5k at this moment) and guides about acronyms which say:

Acronyms and initialisms should always be all capitalized, or all lowercased.

Why? Names are for readability, not to appease a computer algorithm.

// bad
import SmsContainer from './containers/SmsContainer';

// bad
const HttpRequests = [
  // ...
];

// good
import SMSContainer from './containers/SMSContainer';

// good
const HTTPRequests = [
  // ...
];

// also good
const httpRequests = [
  // ...
];

// best
import TextMessageContainer from './containers/TextMessageContainer';

// best
const requests = [
  // ...
];

Answer 2

UNESCO is a special case as it is usually ( in English ) read as a word and not an acronym - like UEFA, RADA, BAFTA and unlike BBC, HTML, SSL

Answer 3

getUnescoProperties() should be the best solution...

When possible just follow the pure camelCase, when you have acronyms just let them upper case when possible otherwise go camelCase.

Generally in OO programming variables should start with lower case letter (lowerCamelCase) and class should start with upper case letter (UpperCamelCase).

When in doubt just go pure camelCase ;)

parseXML is fine, parseXml is also camelCase

XMLHTTPRequest should be XmlHttpRequest or xmlHttpRequest no way to go with subsequent upper case acronyms, it is definitively not clear for all test cases.

e.g. how do you read this word HTTPSSLRequest, HTTP + SSL, or HTTPS + SL (that doesn't mean anything but...), in that case follow camel case convention and go for httpSslRequest or httpsSlRequest, maybe it is no longer nice, but it is definitely more clear.

Answer 4

The JavaScript Airbnb style guide talks a bit about this. Basically:

// bad
const HttpRequests = [ req ];

// good
const httpRequests = [ req ];

// also good
const HTTPRequests = [ req ];

Because I typically read a leading capital letter as a class, I tend to avoid that. At the end of the day, it's all preference.

Answer 5

There are legitimate criticisms of the Microsoft advice from the accepted answer.

• Inconsistent treatment of acronyms/initialisms depending on number of characters:
  • playerID vs playerId vs playerIdentifier.
• The question of whether two-letter acronyms should still be capitalized if they appear at the start of the identifier:
  • USTaxes vs usTaxes
• Difficulty in distinguishing multiple acronyms:
  • i.e. USID vs usId (or parseDBMXML in Wikipedia's example).

So I'll post this answer as an alternative to accepted answer. All acronyms should be treated consistently; acronyms should be treated like any other word. Quoting Wikipedia:

...some programmers prefer to treat abbreviations as if they were lower case words...

So re: OP's question, I agree with accepted answer; this is correct: getUnescoProperties()

But I think I'd reach a different conclusion in these examples:

• US Taxes → usTaxes
• Player ID → playerId

So vote for this answer if you think two-letter acronyms should be treated like other acronyms.

Camel Case is a convention, not a specification. So I guess popular opinion rules.

( EDIT: Removing this suggestion that votes should decide this issue; as @Brian David says; Stack Overflow is not a "popularity contest", and this question was closed as "opinion based")

Even though many prefer to treat acronyms like any-other word, the more common practice may be to put acronyms in all-caps (even though it leads to "abominations")

• See "EDXML" in this XML schema
• See "SFAS158" in this XBRL schema

Other Resources:

• Note some people distinguish between abbreviation and acronyms
• Note Microsoft guidelines distinguish between two-character acronyms, and "acronyms more than two characters long"
• Note some people recommend to avoid abbreviations / acronyms altogether
• Note some people recommend to avoid CamelCase / PascalCase altogether
• Note some people distinguish between "consistency" as "rules that seem internally inconsistent" (i.e. treating two-character acronyms different than three-character acronyms); some people define "consistency" as "applying the same rule consistently" (even if the rule is internally inconsistent)
• Framework Design Guidelines
• Microsoft Guidelines

Answer 6

Currently I am using the following rules:

1. Capital case for acronyms: XMLHTTPRequest, xmlHTTPRequest, requestIPAddress.

2. Camel case for abbreviations: ID[entifier], Exe[cutable], App[lication].

ID is an exception, sorry but true.

When I see a capital letter I assume an acronym, i.e. a separate word for each letter. Abbreviations do not have separate words for each letter, so I use camel case.

XMLHTTPRequest is ambigous, but it is a rare case and it's not so much ambiguous, so it's ok, rules and logic are more important than beauty.