Skip to content

Instantly share code, notes, and snippets.

@wojteklu
Last active October 6, 2024 15:12
Show Gist options
  • Save wojteklu/73c6914cc446146b8b533c0988cf8d29 to your computer and use it in GitHub Desktop.
Save wojteklu/73c6914cc446146b8b533c0988cf8d29 to your computer and use it in GitHub Desktop.
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.
@manuelhelmerichs
Copy link

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

@MohamedKalokoh
Copy link

Thank you

@sourcesnow
Copy link

thank, not enough time to read 300+ page book

@MAlazhariy
Copy link

Thanks, Robert. This was really helpful.

@jinpa-t
Copy link

jinpa-t commented Jun 4, 2022

Very Nice.

@szaszpeter
Copy link

Useful!

@iamshivprasad
Copy link

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

This is awesome, thank you.

@Erfan1995
Copy link

So informative and useful. Thanks.

@qz8
Copy link

qz8 commented Jul 22, 2022

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

Thanks a lot!

@yahya-banouk
Copy link

So informative and useful. Thanks.

@thibauds
Copy link

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

@Victorcorcos if setting is null or undefined the old code is working but not the new code, or am I missing something ?

@davidjohn68
Copy link

davidjohn68 commented Aug 16, 2022

Your article is very good and informative weaver wordle phrazle It gives me a lot of knowledge as well as information.

@KhalilMensi
Copy link

Many thanks, so informative and useful

@vinceAmstoutz
Copy link

vinceAmstoutz commented Oct 12, 2022 via email

@kiraka42
Copy link

kiraka42 commented Nov 9, 2022

"Needless Complexity",
Depends on what means complexity, sometimes the code is more complicated when more proper,
simple example: use of 'for' loop look pretty easy to understand, while now especially in TS/JS we use functional programming, which can be very unwritable when too much action on it (filter, reduce (...)) , yet the second one will be more "clean code"

@ThisOtterBeGood
Copy link

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

Or you could just paste an "obfuscated" ((a && b) || (b &&c) || (!a && !c)) version of your condition into https://www.wolframalpha.com/ and let it do the work. (Minimal forms)

@aota18
Copy link

aota18 commented Dec 9, 2022

Thank you :) It helps a lot! 😆

@azizchelchel
Copy link

Useful recommandations

@Oluwafemimicheal
Copy link

Wow, that Cool Thanks 👍

@NidusUmbra
Copy link

Turns out paying too much attention to the "cleanliness" of your code can have significant drawbacks. Such that it may become indefensible.

https://www.youtube.com/watch?v=tD5NrevFtbU

@brianmcconnel
Copy link

Turns out paying too much attention to the "cleanliness" of your code can have significant drawbacks. Such that it may become indefensible.

https://www.youtube.com/watch?v=tD5NrevFtbU

It seemed like he was looking to prove his point rather than being honest about it. I very rarely need to depart from these principals to make performant code.

@OmarLaham
Copy link

Appreciate your efforts. Very useful.
Thanks

@cgsandford
Copy link

Some testing principles I can't resist noting here - pretty sure I got them from this book:

  • Test interface not implementation
  • All untested code is broken, you just don't know it yet!

Thank you for the summary!

@tharper1977
Copy link

Great page. Tou covered it well.

@madeso
Copy link

madeso commented Apr 29, 2023

Petition to remove "Have no side effects" from "function rules". Side effects in the clean code book referrers to a function doing two or more things but only saying it does one thing. Since functions should only do one thing in the first place this rule is just repeating another rule with a worse wording.

Clean code (the book) actually prefers functions to have side effects (regular meaning now) if you can reduce the number of arguments it takes. This is never stated but it's evident by the clean code sample at the end of that chapter.

@lemieuxhelmsi
Copy link

Very informative! If did something a certain way and do all similar things in the same way as concrete wall contractors Dallas!

@SHAM-BHU123
Copy link

Nice

@luisdatec
Copy link

Thanks. I used it as a reference to improve my codes from now!

However, I will read that book.

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