Prahlad Yeri

Posted on Jul 10, 2019 • Edited on Jul 11, 2019

Pascal Case under_scores, camelCase and PascalCase - The three naming conventions every programmer should be aware of

#productivity #beginners

The various tokens in your code (variables, classes, functions, namespaces, etc.) can be named using one of these three styles, broadly speaking:

Camel Case (ex: someVar, someClass, somePackage.xyz).
Pascal Case (ex: SomeVar, SomeClass, SomePackage.xyz).
Underscores (ex: some_var, some_class, some_package.xyz).

In camel casing, names start with a lower case but each proper word in the name is capitalized and so are acronyms. For example, commonly used tokens in many languages such as toString, checkValidity, lineHeight, timestampToLocalDateTime, etc. are all examples of camel casing.

Pascal casing is similar to camel casing except that the first letter also starts with a capital letter (SomeClass instead of someClass).

In underscore casing, everything is in lower case (even acronyms) and the words are separated by underscores (some_class, some_func, some_var, etc). This convention is also popularly known as snake case.

The general idea is that you can use any convention in your project as long as you are consistent about using it everywhere. But when you code for a large project or team, you should conform to the norm of what is being used there. Hence, its helpful to be aware of the conventions typical in various programming languages.

The general practice for a C style language like Java or JS is to use camelCase for all variables and object members (properties & methods), and PascalCase for class names and constructors. Namespaces (or Packages in Java world) are usually in camelCase.

But some languages make an exception to that. C#, for example, uses PascalCase for namespaces and even public methods. Hence, the main function (or entry point) is always static void main() in java but static void Main() in C# (Note the capitalization of the word "Main").

Some languages which don't derive their syntax from C (such as Python & Ruby) use underscores for almost everything except class names. Hence, its always sys.base_prefix instead of sys.basePrefix, datetime instead of DateTime, str.splitlines() instead of str.splitLines() in python.

In case of python's standard library, I've noticed that even the classes use underscores sometimes which is an inconsistency. For example, datetime.datetime is a class and so is csv.excel_tab. The popular frameworks and libraries though (such as django and flask) use the camel case for classes.

Similar inconsistency is in PHP. The language is evolving from underscores to camel casing in recent years but some old tokens still haunts that language. For ex, mysqli::set_local_infile_default vs PDOStatement::debugDumpParams.

So, ultimately, it comes down to your own preference when you are starting a project. But it helps to know what are the usually followed conventions in popular open source projects in the language of your preference.

Update

There is a fourth case too as pointed out by @ovais, namely kebab case. Its very much like underline casing except that the underlines are replaced with hyphens (dashes). So, some_func becomes some-func which is obviously disallowed because dash isn't used for naming tokens as its already a built-in for the minus operator in most programming languages. Where kebab case is used most frequently is for creating classes in your css stylesheets! Names like main-div, main-navbar and article-footer are commonly used by web developers while writing their HTML/CSS. This convention is basically the kebab case.

Update

As @patrykrudnicki says, constants are handled differently. In my experience, the full underscores (SOME_CONST) is a popular convention for constants in many languages including Java, PHP and Python.

Update

To summarize, this is the typical or generally followed convention in the most used open source programming languages:

Token	python	Java/JS	PHP
variable	under_score	camelCase	mix (moving towards camelCase)
function	under_score()	camelCase()	mix (moving towards camelCase())
constant	UNDER_SCORE	UNDER_SCORE	UNDER_SCORE
class	PascalCase	PascalCase	mix (moving towards PascalCase)
namespace	under_score	camelCase	mix (moving towards PascalCase)

Some helpful links:

Top comments (16)

Juan Carlos • Jul 10 '19 • Edited

nim-lang.org is "Style Agnostic", AKA Style Insensitivity,
you can use Snake Case or Camel Case the way you like it.

var someVar, somePackage = "Camel Case"
echo some_var, some_package

var other_var, other_package = "Snake Case"
echo otherVar, otherPackage

var `kebab-case` = "Kebab Case"
echo `kebab-case`

var `for` = "Stropping allows to use Keywords as names"
echo `for`

type Cat = object  
var cat = "variable cat is not overwritten by Cat object"
echo Cat, cat

# echo prints to terminal (this is a comment)

## No name shadowing or overwriting here
## (This is a DocString, can be Markdown, ReSTructuredText or plain-text)

Its also for interoperability with other programming languages that may use different style,
eg. if you code Python with PyQt, it breaks the style beyond repair because everything is CamelCase on PyQt and everything is snake_case on Python.

Heres an Interactive Demo on the Nim Playground (click on RUN).
👑😎👍

Truong Hoang Dung • Jul 10 '19

Never use any of those.

One reason: In some RDBMS, column name is insensitive about those cases.

Use first_name instead of firstName , or FirstName and you'll always be fine.

Prahlad Yeri • Jul 10 '19

Yep, even in php, function names are case insensitive. A call to someFunc() or SomeFunc() or even somefunc() all go to the same function.

Truong Hoang Dung • Jul 10 '19

I see some devs prefer firstName over first_name, which i see is a way to confusion if you use , for example PostgreSQL as column name.

I don't understand why they prefer that option. Maybe because it's "prettier" ?

Phuc Tran • Apr 11 '20

I'm from Java/Dart background, I also had a similar question for python.
I was thinking why we should type 1 more "_", of course this will take very short time for 1 variable or 1 method, but we will have many of them in a program.

I don't mean underscore is bad, it depends on what you prefer!

Mohd Ovais • Jul 10 '19

I believe it widely known as Kebab Case (kebab-case) instead of Underscore.

Prahlad Yeri • Jul 10 '19 • Edited

No, kebab case is different. Its the dash or hyphenated case, so dashes are used instead of underscores (to-string instead of to_string). The only place where kebab case is used is perhaps css class names (main-div, navbar-div, etc.).

The popular name for underscore case is in fact, snake case.

mar • Jul 10 '19

/kebab case/ as you call it is defacto standard naming convention in all Lisp's, starting room Scheme, trough Common Lisp, up to Clojure. It is phenomenon older than C and still going strong with her and current implementations.

Mohd Ovais • Jul 10 '19

My bad, you are correct!

Patryk Rudnicki • Jul 10 '19

I don’t know the naming, but probably in Java constant value you’re naming in all camel case characters with underscore between words. Good to add this too if this is the official naming convention.

Prahlad Yeri • Jul 10 '19

Thanks, I've updated the post with this point.

Patryk Rudnicki • Jul 10 '19

Yeah, great. Good to point it too. But I mean SOME_VAL not Some_Val. Never seen this approach

Prahlad Yeri • Jul 10 '19 • Edited

Yep, SOME_VAL is full underscores, not a variation of camel case chars, and its the more popular one. Some_Val is a mix of camel and underscores, its less popular and rarely used.

Daragh Byrne • Jul 11 '19

Lets not forget the highly authoritative MACRO_CASE!

Sophie The Lionhart • Jul 10 '19 • Edited

What you refer to as camelCase is sometimes called lowerCamelCase and what you call PascalCase is sometimes called UpperCamelCase. Also the underscore_style is sometimes called snake_case.