[转]Clean Code Principles: Be a Better Programmer
原文: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的更多相关文章
- Clean Code of JavaScript
Clean Code of JavaScript 代码简洁之道 JavaScript 版 https://github.com/ryanmcdermott/clean-code-javascript ...
- Writing Clean Code 读后感
最近花了一些时间看了这本书,书名是 <Writing Clean Code ── Microsoft Techniques for Developing Bug-free C Programs& ...
- 说说怎么写clean code
前两天参加了公司组织的一个培训,主题是“如何写出好的代码” ,刚看到这个主题,第一反应是又不知道是哪个培训机构来忽悠钱的!老大安排了,就去听听呗. 说实在的,课程内容没有什么新鲜的东西,就是讲讲如何发 ...
- 小课堂week13 Clean Code Part2
Clean Code Part2 对象与数据结构 首先让我们进行一个严肃的思考,对象与数据结构的区别在哪里? 如下两段代码分别用数据结构和对象的方法来描述了一个Point. public class ...
- 小课堂Week12 Clean Code Part1
小课堂Week12 Clean Code Part1 今天的主题是函数,让我们看一个函数,找一找其中的"不整洁". 我们也根据这段代码,讨论下对于整洁代码的两个重要原则. publ ...
- “Clean Code” 读书笔记序
最近开始研读 Robert C.Martin 的 “Clean Code”,为了巩固学习,会把每一章的笔记整理到博客中.而这篇博文作为一个索引和总结,会陆续加入各章的笔记链接,以及全部读完后的心得体会 ...
- Clean Code–Chapter 7 Error Handling
Error handling is important, but if it obscures logic, it's wrong. Use Exceptions Rather Than Return ...
- Clean Code – Chapter 4: Comments
“Don’t comment bad code—rewrite it.”——Brian W.Kernighan and P.J.Plaugher The proper use of comments ...
- Clean Code – Chapter 3: Functions
Small Blocks and Indenting The blocks within if statements, else statements, while statements, and s ...
随机推荐
- 【数学】At Coder 091 D题
[深夜题解] 题目链接:https://arc091.contest.atcoder.jp/tasks/arc091_b 题目大意:给出两个正整数N.K,找出所有的不大于N的正整数对(a,b)使b%a ...
- linux——(5)文件与文件系统的压缩与打包
概念一:常见的压缩文件拓展名 .z compress程序压缩的文件. .gz gzip程序压缩的文件. .bz2 bzip2程序压缩的文件. .tar tar程序打包的数据,并没有压缩过. .tar. ...
- jsp有哪些动作作用分别是什么?
JSP共有以下6种基本动作: jsp:include:在页面被请求的时候引入一个文件. jsp:useBean:寻找或者实例化一个JavaBean. jsp:setProperty:设置JavaBea ...
- 【BZOJ 4710】 4710: [Jsoi2011]分特产 (容斥原理)
4710: [Jsoi2011]分特产 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 99 Solved: 65 Description JYY 带 ...
- [BZOJ5427]最长上升子序列
考虑O(n log n)的LIS求法,dp[i]表示到目前为止,长度为i的LIS的末尾最小是多少. 当当前数确定时直接用LIS的求法更新dp数组,当不确定时,由于这个数可以是任意数,所以可以接在任意上 ...
- [BZOJ4870][六省联考2017]组合数问题(组合数动规)
4870: [Shoi2017]组合数问题 Time Limit: 10 Sec Memory Limit: 512 MBSubmit: 748 Solved: 398[Submit][Statu ...
- [CC-CHEFGRPH]Time to Study Graphs with Chef
[CC-CHEFGRPH]Time to Study Graphs with Chef 题目大意: 一个有向图可以分成\(n+2(n\le10^{12})\)层,第\(0\)层和第\(n+1\)层有\ ...
- SpringMVC 常用注解 详解
SpringMVC 常用注解 详解 SpringMVC 常用注解 1.@RequestMapping 路径映射 2.@Requ ...
- bzoj 1026
很久以前做过的一道数位DP,现在用一种新的解决数位DP的比较一般的方法. 数位DP裸题是:求[L,R]有多少个数. 先转化成求[0,R]有多少个数,然后区间相减即可. 对于[0,R]中的所有数,用0补 ...
- UESTC 2015dp专题 G 邱老师玩游戏 背包dp
邱老师玩游戏 Time Limit: 20 Sec Memory Limit: 256 MB 题目连接 http://acm.uestc.edu.cn/#/contest/show/65 Descr ...