Clean Code (Chapter 1 - 3)
Tags: beginners, career
Published: 2022-06-13 14:36:28

![Minesweeper Game](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/db2sq607wd14nht90jie.png)
The book Clean Code talks about how to write code that is understandable and maintainable. It seems like a next step after Leetcode. Let's see an example from a mine sweeper game. Could you understand the example on the left? Was the right one easier to understand?
![Leetcode VS Clean code](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7hinkzlp4rzgspr8ohsh.png)
 
The first 3 chapters of this book is introductory, covering 1. Clean Code, 2. Meaningful Names, 3. Functions.

## FOREWORD
#### Philosophy of Clean Code
- Small things matter. And their value is nonetheless far from small. Attentiveness to detail is the critical foundation of professionalism. Through practice of the small, one gains proficiency and trust for the large.
- One lifetime, many masters. Everyone's perspective on what makes good code differs. What is important is to improve judgement.
- Put it into practice. Like riding a bike, even with all the physics equation of how to work, you'd still fall the first time you ride. Practice, make mistakes, and learn.

#### Splitting of the Book
Part 1 is on the good practices, Part 2 is on the case studies (you should work through these!), Part 3 is the intuition gained.

## Chapter 1: Clean Code
Bad code usually happens because we try to develop too fast. When we say we'd go back to clean it up later, it usually does not happen. The code becomes twisted. Each new feature needs more twists to fix things. Over time, the mess becomes so big that it becomes incredibly difficult to clean it up.
**As developers, we are important to tell PMs to slow down development if we need time to keep things clean. Else, we set up bad expectations that we can deliver too fast.**

> You know you are working on clean code when each routine you read turns out to be pretty much what you expected. You can call it beautiful code when the code also makes it look like the language was made for the problem. - Ward Cunningham, inventor of Wiki

Why clean code matters? From playback of Emacs, reading : writing code time was in the ballpark of 10:1

#### The Boy Scout Rule

> Leave the campground cleaner than you found it.

If we all checked-in our code a little cleaner than when we checked it out, the code simply could not rot. The cleanup doesn’t have to be something big. Change one variable name for the better, break up one function that’s a little too large, eliminate one small bit of duplication, clean up one composite if statement.

## Chapter 2: Meaningful Names
![Good Variable Names](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cdo5c5ftr93rt10h9g6k.png)
#### Use Searchable Names
![Searchable Names](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/z9n09g27bkizclqw760q.png)
#### Method & Class Names
Class Names should be nouns, for example Customer, Account, AddressParser. Method Names should be verbs, for example postPayment, deletePage, or save.
#### Avoid jumping "level of abstraction"
![Keeping Level of Abstraction](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0wvw3kx86przkpg9hakh.png)
 
## Chapter 3: Functions
Functions could be 3000-line, 100-line, but should hardly be 20-lines long. And they should only do one thing.
How to determine?
See below code, it's easy to tell it does 3 things:

1. Determining whether the page is a test page. 
2. If so, including setups and teardowns. 
3. Rendering the page in HTML. 

Notice that the 3 things are one level of abstraction below stated name of function. Thus function is doing one thing.
Another way to know that a function is doing more than “one thing” is if you can extract another function from it with a name that is not merely a restatement of its implementation.
<TODO insert image>

Indent levels should not be greater than two.
Arguments are best kept at zero. More than three (polyadic) requires very special justification.
See two-argument function:

```
assertEquals(expected, actual)
```

See how easy it is to mix up the expected and the actual.

How to reduce argument objects:

```
// Dont use this
Circle makeCircle(double x, double y, double radius);
// Use this
Circle makeCircle(Point center, double radius);
```