Today we are going to look at Naming conventions you can follow while writing code.
Naming conventions lay down the basic rules for naming different elements in your code. The objectives are simple:
- Make the element easy to read
- Should be self explanatory
- Should contain information in a compact and concise manner.
Ideally a well named variable or function should not need a comment to explain what it is for.
With the above objectives in mind let us look at some of the naming conventions that can be followed. The examples are from the Swift & C++ programming languages.
Camel Case Names
In camel case naming convention the entire name of the element is constructed by forming a sentence joined into a single word. So for example if we have a variable for keeping track of the price of oil in US dollars then the variable name might be priceOfOilUSD.
Here are some examples of naming conventions with the camel case.
var priceOfOil : Float = 23.49
float priceOfOil = 3.45;
Underscore Separated Names
In the underscore separated naming convention the entire name of the element is constructed by forming a sentence joined together with the help of underscores in-between them. So if we take the example of the variable keeping track of the price of oil in US dollars the the variable name might be price_of_oil_usd.
var price_of_oil : Float = 45.71
float price_of_oil = 99.87;
Names with type information
A naming convention that is quite popular is the one that mixes the previous 2 naming conventions, with the underscore used to separate the type description in the prefix. So if we take the example of the variable keeping track of the price of oil in US dollars then the variable name might be f_priceOfOil or float_priceOfOil. Either of the design styles work. The prefix is popularly abbreviated and you can create your own rules for abbreviating the type description.
This style is often referred to as the Hungarian notation. The additional information that is provided as a part of the prefix can be:
- Whether the variable is a pointer
- Whether the variable is an object
- The scope of the variable
- Type size
- Whether the data can vary or is a constant
var f_priceOfOil : Float = 0.0
float f_priceOfOil = 22.3;
int *ptr_memmoryBuffer = NULL; //ptr indicates variable is a pointer
There are some rules that are typically followed while designing names for variables and functions. Like the conventions themselves the rules are not binding but they are very useful an give the added punch that naming conventions provide.
- Variable names always start in lower case.
- Type names always start in upper case.
- The naming conventions is consistently applied through all the projects
- Names should be kept as small as possible without sacrificing on the description
As far as strategies are concerned there are multiple approaches that one can follow. Here are some potential strategies.
- Follow one naming convention for variables and another convention for functions.
- Let constants be all upper case
- Prefix types with your companies initials.
The above illustrate just some of the naming conventions that can be followed. By no means are they comprehensive or complete. Also it is not necessarily true that everyone follows the above naming conventions. You may find that many software development firms have their own unique naming convention. This article should give you an an idea about naming conventions. Feel free to share some naming conventions that you have come across.