Common Coding Standards You Should Implement

Image Source

What are coding standards?

Coding standards are simply a set of principles, guidelines and rules that guide software developers on how to structure their code. It can also be considered a benchmark to measure their code base against.

In the context of this article, what we mean by “coding standards” is not the formally promulgated standards set out for, say C and C++, such as the MISRA standards. What we mean here are the generalized practices that can be applied to any language.

Some other terms used for coding standards are “coding conventions” or “style guides”. For example, the AirBnB JavaScript style guide and the Google Style Guide.

Why are coding standards important?

There are two ways to look at the quality of a software product — the software itself and the code base behind it.

A good software is one that is safe and secure for users, is reliable and is expected to work in every production environment it’s meant to be in.

A good code base has the following qualities: maintainable, reusable and testable. Maintaining uniformity of code within an entire organization is very important for teams to be able to work on the same project without facing breaks in the ability to read the code across different departments and teams. Reusable code means the team can avoid having to rewrite modules that do the exact same thing. Testable code allows for quick correction when bugs appear (and they do appear).

Coding standards ensure the above are satisfied at each point in the development process (and beyond). The bigger the project, the more necessary standards become as it’s harder to integrate new team members without an organization-wide accepted way of doing things. Besides, having complex code that is hard to maintain and reuse will increase man hours and building new software will be more costly.

List of common coding standards that you should implement right away

Directory structure and file naming conventions

This governs how your files are organized per project. This also provides instructions on how to name each file such that it can easily be indexed and sorted later on.

This helps each team member to quickly search and acquire the files and directories they need for a particular task.

Code indentation and format

Proper code indentation will help code reviewers and collaborators to easily read through the code. Thousands of lines of code without indentation can quickly irritate any reader. Properly indented code also helps the coder themselves because it’s easier to see the context of each line.

Variable naming conventions

Having variable names that are meaningful will ensure each team member can easily understand code that they didn’t write themselves. This also helps the engineer make sense of the particular function or context for which that variable is being used.

Often the variable name format is governed by the programming language used. For instance JavaScript follows the kebab format (i.e. “iAmAVariable”) while Ruby follows the snake-case format (i.e. “i_am_a_variable”).

Testing standards

In practicing TDD, the team should also have some guidelines on how to approach testing and what tools, libraries and frameworks they should use for which kind of test.

For instance, most code bases benefit a lot from Static Application Security Tests (SAST). Each developer in the team then should know how to integrate SAST and in which stage of the development to do so, as well as which tool they must install.

Using standardized and repeatable testing processes, the team can ensure efficient and effective correction of bugs and vulnerabilities.

DRY (don’t repeat yourself)

This is a fundamental concept all developers abide by. It simply means code that can be modularized should be modularized in order to avoid repetitive code. Modularization simply means creating functions and methods or internal libraries that can be integrated into each project.

Avoiding use of global variables (or limiting its usage)

Global variables are normally frowned upon in the coding community — for good reasons. Global variables can (and always will be) changed during its lifetime in the code base. Therefore, in huge code bases it’s easy to forget the correct value of this variable. This may result in hard-to-debug programs.

At any cost, projects shouldn’t have any global variables in them. But if it’s absolutely necessary, use it. But then appropriate commenting should be in place.


Properly documenting the code base will help the company and the various teams working on each project to quickly see important information about it such as:

  • Change logs
  • Issues (both open and resolved)
  • Reviews done on the project
  • Authors of each change in the code

Remote repositories such as Github are a software development team’s best friend in that they make it easy to document the code base.

To conclude — coding standards make you a better engineer

Software engineering is no different from other engineering disciplines. Standards provide an objective measure of one’s coding skills. Understanding which areas of one’s code are weaker than the standard helps the leadership team identify training opportunities.

More importantly, the better a coder becomes at turning over quality code, the higher the value of such a coder in the team.

Entrepreneur | Funnel Hacker | Software Engineer | Most Importantly A Child of God in Christ Jesus

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store