Chapter 1: Introduction to Clean Code

If you find yourself reading this, it’s likely that you engage in coding regularly. You might even be quite passionate about it. Yet, as developers, we often spend significantly more time reading code than writing it—about ten times more, in fact. This process can sometimes be frustrating, as we encounter incomprehensible, disorganized code. It's a common scenario that many of us have experienced, both in code written by others and our own.

Without proper attention, our codebases can deteriorate rapidly. The repercussions of a disorganized codebase are substantial, impacting both our companies and our mental health. Code that is poorly managed can turn projects into daunting challenges, where even seasoned engineers hesitate to tread. Fortunately, with some straightforward techniques, we can enhance our code quality:

• Abstract conditional (if) statements into clearly named methods
• Replace comments with self-explanatory code
• Create cleaner functions
• Avoid switch statements by utilizing polymorphism
• Begin with the end in mind—visualize your final code and work backward

I will illustrate these five techniques with practical JavaScript examples, which many are familiar with, although these principles can be applied across various programming languages. You can find all code examples on my GitHub repository.

Chapter 2: Understanding Clean Code

The ultimate objective is to achieve Clean Code. Many junior developers mistakenly believe that writing clean code is an innate skill, developed over time. In truth, even the most seasoned developers don’t produce flawless, elegant code on their first try.

Crafting high-quality code is an iterative process that typically involves significant refactoring. Most of the techniques we will discuss fall under this category.

The Red-Green-Refactor Cycle

To enhance our coding practices, it's essential to have reliable tests in place so that we can refactor with confidence. Initially, we may write untidy procedural code accompanied by tests to verify its functionality. The critical phase comes next: refactoring our code to improve clarity and maintainability.

Developers often skip the crucial step of cleaning up code. Without tests, we may hesitate to refine our code at all. Google has an insightful philosophy regarding this:

The Beyoncé Rule – “If you liked it, then you shoulda put a test on it.”

1. Abstract Conditional Statements

The first refactoring technique is straightforward to implement. Consider the code that determines whether a person can enter a nightclub. The initial conditional statement can be quite complex and challenging to understand. By abstracting it into a function with a meaningful name, we enhance readability.

The 'magic' numbers present in the initial code can be replaced with descriptive constants that clarify their purpose.

2. Replace Comments with Declarative Code

Comments are frequently misused in programming. Well-structured, declarative code should be self-explanatory, eliminating the need for excessive comments. Comments should only be used in rare cases where edge conditions cannot be easily understood through the code.

For example, code that retrieves the top ten rated responses from a forum can often be simplified by renaming functions and variables, reducing the need for comments.

3. Create Cleaner Functions

Smaller functions are generally preferable. They are easier to comprehend, reuse, and optimize. A function should perform a single action. If you find yourself crafting complex function names like getDataAndThenMapAndSendToCustomer, it’s time to refactor.

Adhering to the following guidelines can help produce cleaner functions:

• Keep functions under 15 lines when possible.
• Use descriptive names.
• Functions should either retrieve or mutate data, but not both.
• Maintain a consistent level of abstraction.
• Avoid using else conditions when feasible.

4. Utilize Polymorphism to Avoid Switch Statements

Switch statements are often considered a sign of poor code design. If necessary, they should be limited to a single occurrence. When similar switch statements appear throughout your code, it’s a signal to refactor using polymorphism.

For instance, a Notifier class that manages notifications across various channels can be enhanced by creating distinct implementations for each notification type, thereby reducing redundancy.

5. Start at the End

This final technique distinguishes the approach of experienced developers from that of less seasoned ones. Many junior developers tend to write code without sufficient planning, only to realize later how to wrap it in methods or tests. This often results in poorly designed classes and APIs.

Conversely, seasoned developers tend to consider the design of their high-level APIs and classes before diving into implementation. This methodology aligns closely with Test-Driven Development (TDD), which emphasizes the importance of planning before coding.

Even if TDD isn't your preferred approach, try to visualize your end result before you begin coding. This foresight can significantly enhance your coding process, especially when writing shared library code for your team.

Remember, achieving Clean Code is an ongoing journey that requires practice, regardless of your experience level. These techniques aim to guide you through this process more effectively.

All code examples and tests can be accessed through my GitHub repository below:

GitHub - matt-bentley/CodingTipsAndTricks: Explore various strategies to enhance your coding skills.

Some tips and techniques to write better code. Contribute to matt-bentley/CodingTipsAndTricks development by creating…

github.com

Discover essential rules for writing better code in this insightful video.

Learn effective strategies to accelerate your coding process with this informative video.