Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Summary of 'Clean code' by Robert C. Martin

Code is clean if it can be understood easily – by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.


General rules

  1. Follow standard conventions.
  2. Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
  3. Boy scout rule. Leave the campground cleaner than you found it.
  4. Always find root cause. Always look for the root cause of a problem.

Design rules

  1. Keep configurable data at high levels.
  2. Prefer polymorphism to if/else or switch/case.
  3. Separate multi-threading code.
  4. Prevent over-configurability.
  5. Use dependency injection.
  6. Follow Law of Demeter. A class should know only its direct dependencies.

Understandability tips

  1. Be consistent. If you do something a certain way, do all similar things in the same way.
  2. Use explanatory variables.
  3. Encapsulate boundary conditions. Boundary conditions are hard to keep track of. Put the processing for them in one place.
  4. Prefer dedicated value objects to primitive type.
  5. Avoid logical dependency. Don't write methods which works correctly depending on something else in the same class.
  6. Avoid negative conditionals.

Names rules

  1. Choose descriptive and unambiguous names.
  2. Make meaningful distinction.
  3. Use pronounceable names.
  4. Use searchable names.
  5. Replace magic numbers with named constants.
  6. Avoid encodings. Don't append prefixes or type information.

Functions rules

  1. Small.
  2. Do one thing.
  3. Use descriptive names.
  4. Prefer fewer arguments.
  5. Have no side effects.
  6. Don't use flag arguments. Split method into several independent methods that can be called from the client without the flag.

Comments rules

  1. Always try to explain yourself in code.
  2. Don't be redundant.
  3. Don't add obvious noise.
  4. Don't use closing brace comments.
  5. Don't comment out code. Just remove.
  6. Use as explanation of intent.
  7. Use as clarification of code.
  8. Use as warning of consequences.

Source code structure

  1. Separate concepts vertically.
  2. Related code should appear vertically dense.
  3. Declare variables close to their usage.
  4. Dependent functions should be close.
  5. Similar functions should be close.
  6. Place functions in the downward direction.
  7. Keep lines short.
  8. Don't use horizontal alignment.
  9. Use white space to associate related things and disassociate weakly related.
  10. Don't break indentation.

Objects and data structures

  1. Hide internal structure.
  2. Prefer data structures.
  3. Avoid hybrids structures (half object and half data).
  4. Should be small.
  5. Do one thing.
  6. Small number of instance variables.
  7. Base class should know nothing about their derivatives.
  8. Better to have many functions than to pass some code into a function to select a behavior.
  9. Prefer non-static methods to static methods.

Tests

  1. One assert per test.
  2. Readable.
  3. Fast.
  4. Independent.
  5. Repeatable.

Code smells

  1. Rigidity. The software is difficult to change. A small change causes a cascade of subsequent changes.
  2. Fragility. The software breaks in many places due to a single change.
  3. Immobility. You cannot reuse parts of the code in other projects because of involved risks and high effort.
  4. Needless Complexity.
  5. Needless Repetition.
  6. Opacity. The code is hard to understand.
@Roszair
Copy link

Roszair commented Apr 3, 2021

This is very helpful. thank you

@gsustek
Copy link

gsustek commented Apr 6, 2021

Where is logging?

@Lolimipsu
Copy link

Lolimipsu commented Apr 8, 2021

Thank you! this is really helpful!

@SucheG
Copy link

SucheG commented Apr 27, 2021

at school: "Comments are important to clarify what you code do"
at book: "Comments are sign that yor code is bad designed"

@axmachina
Copy link

axmachina commented May 14, 2021

Useful.

I did a cheat sheet, it's quite ugly but it's a start :)
clean_code_summary_cheat_sheet

This is awesome!

@sajibriddho
Copy link

sajibriddho commented May 25, 2021

The summery is helpful, Thank you.

@digitalheadhunt
Copy link

digitalheadhunt commented Jun 17, 2021

Thank you ! :)

@gvsharma
Copy link

gvsharma commented Jun 18, 2021

Thank you

@arturkowalczyk300
Copy link

arturkowalczyk300 commented Jun 20, 2021

Thank you so much!

@surendrans
Copy link

surendrans commented Jun 30, 2021

Thank you, This is very useful.

@JerryChin
Copy link

JerryChin commented Jul 1, 2021

Thanks, it can be very helpful.

@rocasespino
Copy link

rocasespino commented Jul 17, 2021

Thanks for the summary, always helpful for develop process.

@emareg
Copy link

emareg commented Jul 20, 2021

Thanks, very nice. Here is another summary (with examples) that is also based on Clean Code:

https://github.com/tum-esi/common-coding-conventions

Class Diagram

These coding conventions were developed as side-product to our lecture “Software Architecture for Distributed Embedded Systems” held by Prof. Sebastian Steinhorst at TUM.

@badrnezhad
Copy link

badrnezhad commented Jul 26, 2021

You're the best. Thanks a lot. <3

@artes14
Copy link

artes14 commented Aug 4, 2021

This is one summary to change my overall experience in developing! Thank you.

@Victorcorcos
Copy link

Victorcorcos commented Sep 4, 2021

This summary is absolutely fantastic.

I use it often on my team to keep the codebase of my team cleaner.

Thank you @unclebob (Robert C. Martin) for bringing out these amazing Clean Code rules!

@erikuus
Copy link

erikuus commented Oct 7, 2021

Here is my summary of Clean Code in gitbook format with code examples:
https://erik-uus.gitbook.io/clean-code/

@Ivan753
Copy link

Ivan753 commented Oct 10, 2021

Here is my summary of Clean Code in gitbook format with code examples: https://erik-uus.gitbook.io/clean-code/

Returns 404

@Victorcorcos
Copy link

Victorcorcos commented Nov 16, 2021

I would like to contribute to this amazing Clean Code hints by one that I noticed it's possible to be done and nobody talks about...

Conditional Simplification

You can always turn a complex conditional into a simpler one through the Propositional Logic rules

Screen Shot 2021-11-16 at 21 27 24

  • References
  1. De Morgan
  2. Tautology
  3. Propositional Logic

Inspired by Robert C Marin's book: Clean Code

@mansha99
Copy link

mansha99 commented Dec 9, 2021

Thanks a lot !!!

@nizam754
Copy link

nizam754 commented Dec 15, 2021

Very Nice. Thanks a lot.

@Viki-Robles
Copy link

Viki-Robles commented Dec 15, 2021

Love it! thats so good thank you

@EngAbdalrhman
Copy link

EngAbdalrhman commented Jan 2, 2022

thanks!

@egementrk
Copy link

egementrk commented Jan 9, 2022

Thanks a lot <3

@alh9
Copy link

alh9 commented Jan 17, 2022

this is great . thanks=))

@shyguy2
Copy link

shyguy2 commented Jan 22, 2022

nice work, thanks a lot :) @wojteklu

@Barazae5
Copy link

Barazae5 commented Mar 7, 2022

This piece is on point.....

@mhalifu
Copy link

mhalifu commented Mar 9, 2022

great thank you now I don't have to create one :)

@alvyynm
Copy link

alvyynm commented May 7, 2022

Thank you.

@adexx70
Copy link

adexx70 commented May 10, 2022

This is of great help! Thanks

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment