How to Write Clean Code: Refactoring and Best Practices.

We’ve all been there – staring down code that should work but is practically unreadable. And let’s be real: every developer (yes, every single one of us) has written code like that at some point. The good news? Refactoring is a skill you can learn, and clean code is within reach.

So, let’s dive into what it really means to write clean code – not the abstract, “just make it neat” type of clean code, but the kind that’s readable, maintainable, and, dare I say, almost beautiful.

1/ Name Things Like You Mean It
Clean code starts with clear naming. Not x, temp, or data. Your variables and functions need to tell a story.

Example:

2/ Less Is More: The Power of Function Size
Ever seen a function that’s as long as a novel? Let’s be real – long functions are painful. Clean code thrives on small, single-purpose functions. Think of each function as a building block: it should have one job, and it should do it well.

Example:

3/ Consistency Is Key
Think about this: if you call one array userList, don’t call the next one users. Consistent naming, indentation, and formatting save everyone time because they create a pattern – a rhythm – that makes the code predictable.

Example:

4/ Comment With Purpose, Not Out of Habit
Comments are great, but only if they add clarity. If your code is clean, it’ll need fewer comments. And for the ones you do add, make them valuable.

Example:

5/ Magic Numbers and Hardcoded Values – Get Rid of Them
If you’re hardcoding values everywhere, it’s going to be trouble later. Instead, use constants to make these numbers meaningful.

Example:

6/ DRY: Don’t Repeat Yourself
Repetitive code is a nightmare for maintenance. Instead of copy-pasting, find a way to write reusable functions or modules that handle repetitive logic.

Example:

7/ Keep Your Code SOLID
SOLID principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion) might sound like corporate buzzwords, but they’re surprisingly practical for writing clean code. If you’re new to these principles, start with the Single Responsibility Principle: each class or function should have one responsibility and one alone.

Example:

8/ Refactor Ruthlessly
Refactoring isn’t just a one-time thing; it’s a mindset. Every time you review your code, look for areas that can be improved. Refactoring is about recognizing that code is rarely perfect the first time. Don’t be afraid to keep changing things up until they’re truly clean.

Example:

If you can nail these fundamentals, you’re already way ahead of the game.

Comments

[Vitaliy Potapov]

Thanks for the article!
Here is the eslint config, that I use in my projects to follow the clean code rules:

rules: {
  complexity: ['error', { max: 6 }],
  'max-depth': ['error', { max: 2 }],
  'max-nested-callbacks': ['error', { max: 2 }],
  'max-params': ['error', { max: 3 }],
  'max-statements': ['error', { max: 12 }, { ignoreTopLevelFunctions: false }],
  'max-len': ['error', { code: 120, ignoreUrls: true }],
  'max-lines': ['error', { max: 200, skipComments: true, skipBlankLines: true }],
  'max-lines-per-function': ['error', { max: 30, skipBlankLines: true, skipComments: true }],
},

[Balraj Singh]

Wow. Perfect!

[Sami]

Eslint can check this wow. Thanks

[Lakhan Jindam]

Good points!
I think refactoring should be done proactively but if it's affecting your deliverables then at least it should be tracked in your project management software otherwise it keeps on piling and becomes a tech debt eventually :(

[Balraj Singh]

Proactive refactoring is ideal, but when timelines are tight, tracking it in your project management tool is crucial. It not only keeps it visible but also ensures it gets prioritized before turning into a full-blown tech debt crisis. Balancing progress with maintenance is always tricky, but good tracking helps!

[Balraj Singh]

You're absolutely right!

[Nasrul Hazim Bin Mohamad]

a great place to learn about refactoring - refactoring.guru/

[Balraj Singh]

Thanks for sharing!

[Djamel Bougouffa]

Thanks for sharing these valuable insights.
Clean code is indeed an art that every developer should strive to master!

[Balraj Singh]

True that!

[Anup Khismatrao]

Great article

[Balraj Singh]

Thank you!

[Ibrahima DIALLO]

I would like to have more clarification regarding SOLID principles

But nevertheless, this is a useful article

[KRowin]

Good, solid article, now I know that principles I’ve learned without formal coding education have a fancy corporate like names which I can throw around to refactor the discussion. :)

[Dev Patel]

test