Chapter 3 Be Principled
The Boy Scout Rule
This principle is about you and your behavior. It reads as follows: Always leave the campground cleaner than you found it.
Boy scouts are very principled. One of their principles states that they should clean up a mess or pollution in the environment immediately, once they’ve found such issues. As responsible software craftspeople, we should apply this principle to our daily work. Whenever we find something in a piece of code that needs to be improved, or that’s a bad code smell, we should do one of two things. We should fix it immediately if it is a simple change (e.g., renaming a bad named variable). Or we should create a ticket in the issue tracker if it would result in a major refactoring, for example, in the case of a design or architecture problem. It does not matter who the original author of this piece of code was.
The advantage of this behavior is that we continuously prevent code dilapidation. If we all behave this way, the code simply cannot rot. The tendency of growing software entropy has little chance to dominate our system. And the improvement doesn’t have to be a big deal. It may be a very small cleanup, such as these:
•\ |
Renaming a poorly named class, variable, function, or method (see |
|
the sections “Good Names” and “Function Naming” in Chapter 4). |
•\ |
Cutting the innards of a large function into smaller pieces (see the |
|
section entitled “Let Them Be Small” in Chapter 4). |
•\ |
Deleting a comment by making the commented piece of code |
|
self-explanatory (see the section entitled “Avoid Comments” in |
|
Chapter 4). |
•\ |
Cleaning up a complex and puzzling if-else compound. |
•\ |
Removing a small bit of duplicated code (see the section about the |
|
DRY principle in this chapter). |
Since most of these improvements are code refactorings, a solid safety net consisting of good unit tests, as described in Chapter 2, is essential. Without unit tests in place, you cannot be sure that you won’t break something.
Besides good unit test coverage, we still need a special culture on our team: collective code ownership.
62
Chapter 3 Be Principled
Collective Code Ownership
This principle was first formulated in the context of the eXtreme Programming (XP) movement and addresses the corporate culture as well as the team culture. Collective code ownership means that we should work as a community. Every team member, at any time, is allowed to make a change or extension to any piece of code. There should be no attitude like “this is Sheila’s code, and that’s Fred’s module. I don’t touch them!” It should be considered valueable that other people can easily take over the code we wrote. A set of well-crafted unit tests (see Chapter 2) supports this, as it allows safe refactorings and thus takes away the fear of change. Nobody on a real team should be afraid, or have to obtain permission, to clean up code or add new features to it. With a culture of collective code ownership, the Boy Scout rule explained in the previous section works fine.
63
CHAPTER 4
Basics of Clean C++
As I have explained in Chapter 1, lots of C++ code out there is not clean. In many projects, software entropy has gotten the upper hand. Even if you are dealing with an ongoing development project, for example, with a piece of software under maintenance, large parts of the code base are often very old. The code looks as if it were written in the last century. This is not surprising, since most of that code was literally written in the last century! There are many projects with a long lifecycle, and they have their roots in the 1990s or even the 1980s. Furthermore, many programmers copy code snippets out of legacy projects and modify them to get things done in their daily work.
Some programmers treat the language just like one of many tools. They see no reason to improve something, because what they cobble together works somehow. It should not be that way because this approach will quickly lead to increased software entropy, and the project will turn into a big mess quicker than you think.
In this chapter, I describe the general basics of clean C++. These are universal topics that are often programming language independent. For example, paying attention to good names for any kind of software unit is essential in all programming languages. Several other aspects, like const correctness, using smart pointers, or the great advantages of move semantics, are specific for C++.
But before I discuss specific topics, I want to point out a general piece of advice, which is to use the latest version of C++ if at all possible.
Tip If you are not already doing so, start to develop your software using modern C++ now. Skip C++11 and start right away with C++14, C++17, or even better: C++20!
Why should you skip C++11? Well, C++11 was a big hit, no doubt, but it was also not perfect and in certain areas a bit flawed. For instance, C++11 lacked generic and variadic lambdas and didn’t support full auto return type deduction. Thus, it is reasonable and
65
© Stephan Roth 2021
S. Roth, Clean C++20, https://doi.org/10.1007/978-1-4842-5949-8_4