原文:https://www.webcodegeeks.com/web-development/clean-code-principles-better-programmer/

-----------------------------------------------------------------

“My code is working well, the website I built is looking great, and my client is happy. So why would I still care about writing clean code?”

If this sounds like you, then read on.

A little while ago, I was having a discussion with one of my friends, Kabir. Kabir is an experienced programmer. He was working on a complex project, and he was discussing a problem with me. When I asked to see the code for that problem, he said, sounding proud, “I built this project so we are the only ones who can understand the code.”

I was pretty horrified. I asked him if he deliberately wrote dirty code.

“The client didn’t give me enough time,” my friend told me. “He is always in a hurry and pushing for deliveries, so I did not have time to think about cleaning it up.”

This is almost always the excuse I hear when I ask about dirty code.

Some programmers write dirty code because they plan to release the first working version and then work to make it clean. But it does not work; no client gives you time to clean code. Once the first version is released, they will push you for the second. So, make it a habit to write code as clean as you can from the first line of code.

I’ve always learned that using clean code principles has many benefits down the line, and this post will show you why.

 

It is the job of the project manager, sales head, or client to get the project done in minimum time so they can control the cost of the project. But producing quality, clean code is your duty as the programmer.

Writing clean code is not a big or time-consuming task, but making it your routine, and committing to it, will go a long way toward advancing your career and improving your own time management.

Clean code always looks like it was written by someone who cares.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”—Martin Fowler

You’ve probably read this far for two reasons: First, you are a programmer. Second, you want to be a better programmer. Good. We need better programmers.

Keep reading to learn why clean code matters, and you’ll become a better programmer.

Why Should We Strive for Clean Code?

Clean code is readable and easy to understand by everyone whether the reader is the author of the code or a new programmer.

Writing clean code is a necessary mindset. It takes practice to write clean and structured code, and you will learn to do it over time. But you need to start with the mindset of writing this way. And you’ll get used to reviewing and revising your code so it’s the cleanest it can be.

No one is perfect, and so you are not either. You always will find some opportunity to improve or refactor the code when you come back to review your code after a few days or weeks. So, start writing the code as clean as you can from the first line of code so later you can work more on performance and logic improvement.

Benefits of Clean Code

“Why should I care about writing clean code?” you may still be asking yourself.

There are many reasons to get into the clean code mindset I described above. Some of the most important reasons are:

Better Use of Your Time

The first beneficiary of clean code is the programmer themselves. If you are working on a project for months, it’s easy to forget things you did in the code, especially when your client comes back with changes. Clean lines of code make it easier to make changes.

Easier Onboarding for New Team Members

Using clean code principles helps to get a new programmer onboard. There is no need for documentation to understand the code; the new programmer can directly jump into it. This also saves time for both training the new programmer as well as the time it takes for the new programmer to adjust to the project.

Easier Debugging

Whether you write dirty or clean code, bugs are inevitable. But clean code will help you to debug faster, regardless of how much experience or expertise you have.

And it’s not uncommon for your colleagues or managers to help you solve the problem. If you’ve written clean code, no problem: They can jump in and help you out. But if your manager has to work through your dirty code, well, you might end up like my friend Kabir.

More Efficient Maintenance

“Of course bad code can be cleaned up. But it’s very expensive.”
―Robert C. Martin

Maintenance does not refer to bug fixing. As any project grows, it will need new features, or changes to existing features.

Do you know that the major cost of any software project is in maintenance? The company will always release the first version, or minimum viable product (MVP), as early as possible. Additional or new features are always an afterthought as the software gets more use. Clean code makes maintenance relatively fast and easy.

 

These first three points explain how clean code can save a programmer’s time. And, saving a little time every day will have a compound effect on the delivery time and cost of the software. That’s good for your company.

You’ll Feel Good


Does it help you feel confident to share your work with others, too? Or with your client?
If you’re writing quality, clean code, you should feel super confident. You should not have a fear of breakdown; you can fix defects faster.

And that means you’re also probably enjoying the programming.

Now, how do you write clean code?

How To Write Clean Code

“You should name a variable using the same care with which you name a first-born child.”
―Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship

A programmer is an author, but they might make the mistake in identifying the audience. The audience of a programmer is other programmers, not computers. If computers were the audience, then you might be writing the code in machine language.

So, to make it easy to understand for your audience, you should use meaningful nomenclature for variables, functions, and classes. And make it more readable by using indentation, short method, and short statement, where appropriate:

  • Use easily pronounceable names for variables and methods. Do not use abbreviations in the variable and method names. Use the variable name in full form so it can be easily pronounced and everyone can understand it.
Dirty code examples Clean code examples
public $notiSms;
public $addCmt;
public $notifySms
public $addComment;
foreach ($people as $x) {
echo $x->name;
}
foreach ($people as $person) {
echo $person->name;
}
$user->createUser();
createUser method does not make sense as it is written in user class.
$user->create();
Remove redundancy
  • Use the name to show intention. The purpose of the variable should be understandable to someone reading the name of the variable. Write the name as you would speak it.
Dirty code examples Clean code examples
protected $d; // elapsed time in days protected $elapsedTimeInDays;
protected $daysSinceCreation;
protected $daysSinceModification;
protected $fileAgeInDays;
if (‘paid’ === $application->status) {
//process paid application
}
if ($application->isPaid()) {
//process paid application
}
  • Don’t be innovative; be simple. Show the innovation in logic, not in naming variables or methods. Having a simple name makes it understandable for everyone.
Dirty code example Clean code example
$order->letItGo(); $order->delete();
  • Be consistent. Use one word for similar functions. Don’t use “get” in one class and “fetch” in another.
  • Don’t hesitate to use technical terms in names. Go ahead, use the technical term. Your fellow programmer will understand it. For example, “jobQueue” is better than “jobs.”
  • Use a verb as the first word in method and use a noun for class. Use camelCase for variable and function name. The class should start from the capital.
Dirty code examples Clean code examples
public function priceIncrement() public function increasePrice()
Public
$lengthValidateSubDomain
Public $validateLengthOfSubdomain;
class calculationIncentive class Incentive
  • Use consistent naming conventions. Always use uppercase, and separate words with underscores.
Dirty code example Clean code example
define(‘APIKEY’, ‘123456’); define(‘API_KEY’, ‘123456’);
  • Make functions apparent. Keep a function as short as possible. My ideal length of a method is up to 15 lines. Sometimes it can go longer, but the code should be conceptually clean to understand.
  • Keep arguments to fewer than or equal to three. (If arguments are greater than three, then you must think to refactor the function into a class.)

You should also limit a function or method to a single task. (Avoid using “and” in a method name, like “validateAndSave.” Instead, create two methods, one for validation and another for save).

Indentation is also important. Your clean code must use four spaces for indents, not the tab key. If you’re already in the habit of using the tab key, change your IDE setting to make the tab key denote four spaces as opposed to its usual five.

 

If your method has more than three indentations, then it’s time to refactor in new methods.

  • Behavior of class and object. One class should do one thing. If it is for the user, then all methods must be written entirely for the user experience.
  • Don’t comment on bad code. If you have to add comments to explain your code, it means you need to refactor your code and create new methods. Comment only if it is legally required or if you need to keep notes on the program’s future or history.
Dirty code example Clean code example
// Check to see if the employee is eligible for full benefits
if ($employee->flags && self::HOURLY_FLAG && $employee->age > 65)
if ($employee->isEligibleForFullBenefits())
  • Use Git for version history. Sometimes, features change and methods need to be rewritten. Usually, we comment out the old code for fear that clients will make a U-turn and request the older version. But if you use the Git version control system, it will keep all versions stored, so there’s no need to keep dead code. Remove it and make your code clean.
  • Avoid working with a large array. Avoid making an array for a large data set; instead, use a class. That make it more readable, not to mention that it creates an additional safety for your application.
  • Do not repeat the code. Every time you write a method, ask yourself if something similar has already been built. Check the code library or other documentation.
  • Don’t hardcode. Define constant or use variables instead of hardcoding the values. Using the variable will not only make it readable but will also make it easy to change if it is being used at multiple places.
Dirty code example Clean code example
if (7 == $today) {
return ‘It is holiday’;
}
const SATURDAY = 7;
if (self::SATURDAY == $today) {
return ‘It is holiday’;
}
  • Make the statement readable. To make the statement readable, keep the line short so you don’t need to scroll horizontally to read the complete line.

Some Other Tips for Cleaner Code


Review your code yourself. Review your code once in a while. I’m sure you’ll find something new to improve on every time you revisit it.

Review your code with your colleagues. Review your colleagues’ codes, and ask them to review yours. Don’t hesitate to consider suggestions.

Every language has its own naming convention. If you are writing for PHP, use PSR-2’s coding style guide.

To increase the quality of the code, you should use the TDD approach and write unit tests. Test-driven development makes code changes easy; you do not need to fear breakdown of the code. If you made any mistakes, the unit test will fail, and you will know what test case failed and what block of code was responsible for that.

Use the Git version control system to collaborate on development. Git becomes an essential tool when multiple programmers are working on a project. Code review becomes easy if you are using a version control system.

For future reading, check out Clean Code, by Robert C. Martin.

Moving Forward to Cleaner Code

Writing clean code has many benefits, and it’s easy to see why.

With these tips, you can be well on your way to writing code that everyone can understand—and that will make life easier for you in the long run.

It will help your colleagues, your team, and your employer as well.

Published on Web Code Geeks with permission by Rakesh Shekhawat, partner at our WCG program. See the original article here: Clean Code Principles: Be a Better Programmer

Opinions expressed by Web Code Geeks contributors are their own.

[转]Clean Code Principles: Be a Better Programmer的更多相关文章

  1. Clean Code of JavaScript

    Clean Code of JavaScript 代码简洁之道 JavaScript 版 https://github.com/ryanmcdermott/clean-code-javascript ...

  2. Writing Clean Code 读后感

    最近花了一些时间看了这本书,书名是 <Writing Clean Code ── Microsoft Techniques for Developing Bug-free C Programs& ...

  3. 说说怎么写clean code

    前两天参加了公司组织的一个培训,主题是“如何写出好的代码” ,刚看到这个主题,第一反应是又不知道是哪个培训机构来忽悠钱的!老大安排了,就去听听呗. 说实在的,课程内容没有什么新鲜的东西,就是讲讲如何发 ...

  4. 小课堂week13 Clean Code Part2

    Clean Code Part2 对象与数据结构 首先让我们进行一个严肃的思考,对象与数据结构的区别在哪里? 如下两段代码分别用数据结构和对象的方法来描述了一个Point. public class ...

  5. 小课堂Week12 Clean Code Part1

    小课堂Week12 Clean Code Part1 今天的主题是函数,让我们看一个函数,找一找其中的"不整洁". 我们也根据这段代码,讨论下对于整洁代码的两个重要原则. publ ...

  6. “Clean Code” 读书笔记序

    最近开始研读 Robert C.Martin 的 “Clean Code”,为了巩固学习,会把每一章的笔记整理到博客中.而这篇博文作为一个索引和总结,会陆续加入各章的笔记链接,以及全部读完后的心得体会 ...

  7. Clean Code–Chapter 7 Error Handling

    Error handling is important, but if it obscures logic, it's wrong. Use Exceptions Rather Than Return ...

  8. Clean Code – Chapter 4: Comments

    “Don’t comment bad code—rewrite it.”——Brian W.Kernighan and P.J.Plaugher The proper use of comments ...

  9. Clean Code – Chapter 3: Functions

    Small Blocks and Indenting The blocks within if statements, else statements, while statements, and s ...

随机推荐

  1. 2017 计蒜之道 初赛 第五场 A. UCloud 机房的网络搭建

    贪心. 从大到小排序之后进行模拟,注意$n=1$和$n=0$的情况. #include <iostream> #include <cstdio> #include <cs ...

  2. 图像 & 视频

    Python图像处理库:Pillow 初级教程 用Python做图像处理 python 视频处理,提取视频相关帧,读取Excel

  3. Kylin的垃圾清理

    在Kylin运行一段时间之后,有很多数据因为不再使用而变成了垃圾数据,这些数据占据着大量HDFS.HBASE等资源,当积累到一定规模时会对集群性能产生影响.这些垃圾数据主要包括: Purge之后原Cu ...

  4. 【Java】SpringBoot入门学习及基本使用

    SpringBoot入门及基本使用 SpringBoot的介绍我就不多说了,核心的就是"约定大于配置",接下来直接上干货吧! 本文的实例: github-LPCloud,欢迎sta ...

  5. JS延迟执行

    <!DOCTYPE html> <html> <head> <title></title> <script type="te ...

  6. Scrapy爬取女神照片

    使用Scrapy趴一趴美女图 Scrapy,Python开发的一个快速,高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据.Scrapy用途广泛,可以用于数据挖掘.监测和自 ...

  7. 详解Ubuntu Server下启动/停止/重启MySQL数据库的三种方式(ubuntu 16.04)

    启动mysql: 方式一:sudo /etc/init.d/mysql start 方式二:sudo service mysql start 停止mysql: 方式一:sudo /etc/init.d ...

  8. Redis学习篇(十一)之发布订阅

    PUBLISH/SUBSCRIBE 发布订阅的原理 包含两个角色,一个是发布者, 一个是订阅者 订阅者可以订阅一个或者多个频道(channel) 发布者可以向指定的频道发布信息 通过SUBSCRIBE ...

  9. [GCJ2017R2]Fresh Chocolate

    题目大意: 有n个团和很多盒糖,每个团中人数不一定相同,每盒糖中都有p颗糖. 现在要给每个团发糖,要求每个人都要发到糖,只有一盒糖发完后才能发下一盒糖. 发糖的顺序可以任意安排,问经过合理安排后,最多 ...

  10. 【BZOJ】2002: [Hnoi2010]Bounce 弹飞绵羊

    2002: [Hnoi2010]Bounce 弹飞绵羊 Time Limit: 10 Sec  Memory Limit: 259 MBSubmit: 14802  Solved: 7507[Subm ...