Clean code: what makes programming code clean
The concept of clean code can be traced back to Robert Cecil Martin and his book ”Clean Code: A Handbook of Agile Software Craftsmanship” where it was presented as a term for cleanly written code. However, the principles of clean code are much older and did not actually originate in software development. We will explain what clean code is, what its advantages are, and how to write clean code yourself.
What is clean code?
Clean code is not a set of strict rules. It is a set of principles for writing code that is easy to understand and modify. In this case, “understandable” means that the code can be immediately understood by any experienced developer. The following characteristics of clean code are what make it easy to read:
- The entire application’s order of execution is logical and clearly structured.
- The connection between different parts of the code is quite obvious.
- The task or role of each class, function, method, and variable is immediately understandable.
Code is easy to modify if it can be adapted and extended. This also makes it easier to correct errors in the code. Clean code is thus very easy to maintain. Easily modifiable code has the following characteristics:
- Classes and methods are small and only have one single task.
- Classes and methods are predictable, work as expected, and are publicly available through well-documented APIs (interfaces).
- The code uses unit tests.
The advantages of this kind of programming are obvious. Clean code does not depend on the original developer. In principle, any programmer can work with the code. This prevents problems that may occur when working with legacy code, for example. It is also easier to maintain the code because bugs can be identified and fixed more easily.
Overview of clean code principles
But how does one actually write clean code? Writing clean code is about taking certain guiding principles into consideration when programming. It is less about having concrete instructions on what to program in a specific situation and more about reflecting on one’s own development work practices. But what clean code means in concrete terms is a highly debated topic among the communities of developers. What is considered clean to one group of developers might be messy to another. Therefore, how clean a piece of code is will always be somewhat subjective. In the following, you will find some established clean code principles that most developers find useful.
Write code as simply as possible: KISS
KISS (Keep it simple, stupid) is one of the oldest principles of clean code. It was being used by the US military as early as the 1960s. KISS encourages programmers to write their code as simply as possible. You should avoid making your code unnecessarily complex. When it comes to programming, there is never a single way to solve a problem. A task can always be executed using different languages and formulated using different commands. Programmers who follow the KISS principle must, therefore, always ask themselves whether there is an easier way to solve a particular problem.
Avoid unnecessary repetition: DRY
DRY (Don’t repeat yourself) is a more specific version of KISS. According to the DRY principle, functions in clean code should only do one thing within the overall system.
The opposite of DRY is WET (We enjoy typing). Code is WET when there are unnecessary repetitions in the code.
The following is an example of the DRY clean code principle: The username and password are retrieved twice in the code and then used for different actions. Instead of programming both processes separately, they can be combined together in a single function. This turns the WET code with repetitions into DRY code.
WET code:
//Version A
let username = getUserName();
let password= getPassword();
let user = { username, password};
client.post(user).then(/*Version A*/);
//Version B
let username = getUserName();
let password= getPassword();
let user = { username, password};
client.get(user).then(/*Version B*/);DRY code:
function getUser(){
return {
user:getUserName();
password:getPassword();
}
}
//Version A
client.post(getUser()).then(/*Version A*/ );
//Version B
client.get(getUser()).then(/*Version B*/);Delete what is not needed: YAGNI
The clean code principle YAGNI (You aren’t gonna need it) is based on the following idea: a developer should only introduce additional functionality to code when it is necessary. YAGNI is closely tied to agile software development methods. According to the YAGNI principle, instead of starting from an overarching concept during development, you should program the software architecture in small steps to be able to react to problems dynamically and individually. Clean code is, thus, always produced when the underlying problem has been solved in the most efficient way possible.
Readability over conciseness
Code needs to work and be understood by the machine executing it. However, other developers also need to be able to understand the code, especially if you are working on a project with multiple people. That is why the readability of code is always more important than its conciseness when it comes to software development. There is no point in writing concise code if other developers cannot understand it. A good example of producing readable clean code can be found in the naming of variables.
A variable name should always be self-explanatory. The following variable is not understandable without some background knowledge and an explanation:
int d;In contrast, providing the following name for the same variable makes its meaning clear:
int elapsedTimeinDays;Related articles
REDPIXEL.PLShutterstock Pair Programming: The pros and cons
Agile software development is supposed to make the programming process more dynamic and efficient. At first, pair programming might seem counterproductive because two programmers have the same task: They work together on the same piece of code and take turns checking each others’ work. This peer review process is designed to ensure fewer mistakes and better results. How does it work?
REDPIXEL.PLShutterstock Extreme Programming: Software development to the extreme
Programming has been dominated by agile software development in recent decades, and with good reason. Agile software development owes much of this success to the extreme programming (XP) methodology. It doesn’t get any more agile than XP! This methodology emphasises the people involved and requires thinking in very small steps. How does extreme programming work?
Refactoring
Refactoring is a process in software development where manual or automatic adjustments are made to improve inelegant parts of the source code. The aim of refactoring is to produce a source code that is functionally unaltered, yet structurally easily legible and useable. But what advantages and disadvantages does refactoring involve?
Sustainable Web Design
The Internet and the operation of data centres produce around 2.8 percent of global CO2 emissions per year. Sustainable web design can help reduce energy consumption and CO2 emissions – and therefore the eco-balance of the Internet. What is sustainable web design, and how can you create an eco-friendly website? Let’s find out.
How to perform code review
Code review is a quality assurance measure in software development. Its benefits go beyond ensuring code quality. It allows new team members to receive important feedback and facilitates knowledge being exchanged and distributed within the organization. Our article will go into the pros and cons of code review, as well as give an overview of the different methods and tools.
