309 Blog Posts To Learn About Clean Code

17 Jul 2026

Clean code is a software development philosophy emphasizing code readability, maintainability, and understandability. It matters because it reduces technical debt, improves collaboration among developers, and makes software easier to debug and extend over time.

1. Mastering SOLID Principles Like the Back of Your Hand in Just 8 Minutes!

Boost Performance, Maintainability, and Scalability with SOLID Principles in React Applications!

2. 40+ Thought-Provoking Software Engineering Quotes

Sometimes a short thought can bring amazing ideas. There are some great quotes I’ve been collecting. I use them as inspiration or motto for some articles.

3. Using Black To Auto Format Your Python

How to stop worrying and embrace Auto Formatting in your python code.

4. Are Implicit Operators a Path to Clean Code or a Buggy Nightmare?

Implicit operators are a C# feature that can make our code more readable and expressive. But beware! Misuse can backfire and cause a great deal of headaches!

5. Adopting the Repository Pattern for Enhanced Backend Development With FastAPI

In this article, we'll cover the benefits of utilizing the repository pattern in building backend systems with FastAPI.

6. Code Review Anti-Patterns: How to Stop Nitpicking Syntax and Start Improving Architecture

Code reviews are pricey. Let machines catch style issues so humans can focus on what matters: security, scalability, and architecture.

7. Python Static Analysis Tools: Clean Your Code Before Running

Review of essential modern Python code static analysis tools.

8. How To Write Decoupled Code with MediatR: The Mediator Pattern

I recently wrote a blog post introducing some of my favourite NuGet packages: My Top 4 NuGet Packages for ASP.NET Core. In that post, I briefly introduced a package called MediatR. Today, I will dedicate this post to revisiting MediatR in further detail.

9. The Clean Code Book for JavaScript Developers: A Quick Summary

This blog post summarizes the book “Clean Code” written by Robert Martin on how to write a readable and maintainable code.

10. Making Your Code Look Pretty

When you are new to programming, you’re focused on making your code work—not on making it look pretty.

11. 📚 Android Components Architecture in a Modular Word

Marvel kotlin sample application using android components architecture in a modular project

12. Using Kotlin Extension Functions: The Good, the Bad, and the Ugly

Extension functions allow you to natively implement the "decorator" pattern. There are best practices for using them.

13. Clean Code: Single Responsibility, Open/Closed, Liskov Substitution SOLID Principles in TS [Part 4]

In this article, we will look at the three first SOLID principles: The Single Responsibility Principle, the Open/Closed Principle and the Liskov Principle.

14. 400+ Thought-Provoking Software Engineering Quotes

The most complete curated collection of software and programming quotes

15. 100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

Clean Code by Robert C. Martin is the most recommended programming book of all time. There’s a good reason why.

16. A Deeper Dive Into Log Enrichment

In this article, we will conclude reviewing how logging concerns and code can be separated and decoupled from infrastructure and business code.

17. It’s 2023, But We Still Need to Talk About Nested Styles in CSS

Why don't I need to use nested css styles in my product and why is it a bad practice.

18. Why You Should Always Avoid Encoding Type Into Names

The Rule: When naming a variable, don't encode it's type into its name, even in a dynamically typed language.

19. How to Find the Stinky Parts of Your Code (Part I)

The code smells bad. Let’s see how to change the aromas. In this series, we will see several symptoms and situations that make us doubt the quality of our developments. We will present possible solutions. Most of these smells are just hints of something that might be wrong. They are not rigid rules.

20. How to Get Rid of Annoying IFs Forever

Why the first instruction we learn to program should be the last to use.

21. The Double-Edged Sword of Atomic Design

Unlock the potential of Atomic Design in UI development: Benefits, drawbacks, and a comprehensive case study with React.

22. Continuous Integration (CI) Branching Strategies: What You Need to Know

When you have multiple developers working on the same code, you may face a lot of challenges when merging. That's where branches come in.

23. Software Engineer Maxi Contieri on writing about “boring” fundamentals

Maxi is a software engineer and teacher from Argentina. Learn about this talented HackerNoon Writer!

24. Dependency Injection in Dart: An Easy Guide for Beginners

In computer science, a dependency occurs when one component (class, module, etc.) relies on the functionality of another component to operate correctly.

25. Enhance Your Code Architecture With SOLID Principles (with Swift Examples)

Learn how to apply SOLID principles in Swift with clear examples. Understand SRP, OCP, LSP, ISP, and DIP to write clean, scalable, and maintainable code.

26. How To Create a Python Data Engineering Project with a Pipeline Pattern

In this article, we cover how to use pipeline patterns in python data engineering projects. Create a functional pipeline, install fastcore, and other steps.

27. Using A Switch Statement in Python

Yes, you read that right. If you have been coding for a while and if Python is not the first programming language that you started with, then you definitely know what a Switch statement is, and appreciate how flawless it is, when you need to factor in multiple conditions/cases for a control flow.

Explore a structured approach leveraging hooks, context, lazy loading, and Suspense for efficient and scalable dialog integration in React applications.

29. AI Coding Tip 004 - Why You Should Use Modular Skills

Create small, specialized files with specific rules to keep your AI focused, accurate and preventing hallucinations.

30. How to Find the Stinky Parts of Your Code [Part XXXV]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

31. How to Improve Code and Avoid Fights on Review

Unit tests and laziness: a dispute-free method to boost individual skills within tech teams.

32. Using Guard Clauses to Clean Up Your Conditionals [A How-To Guide]

One of the first techniques developers learn is the if/else statement. For obvious reasons if/else statements are a primary way to create logic trees. This is where we handle calculations differently depending on the input variables. However, complex and nested if/else statements become a cognitive burden to reason about. Therefore, it can be hard for the next developer to understand quickly.

33. Principles of a Clean Relational Database

The article describes how a relational database should be designed to properly work in OLTP mode.

34. AI Coding Tools Are Bad News for Lazy Programmers

AI-generated code outperforms lazy programmers. Software jobs are declining, but centaurs will survive.

35. Code That Cleans Itself: A Journey into Automated Refactoring

Join Ayse and her son Mert in a tale that weaves lessons from a teenager's messy room into innovative code refactoring techniques.

36. Helpful Tips for Writing Clean Code

In this short, but nonetheless useful article, I have summarized the most beneficial tips for writing clean code. These rules are independent of the language you use and are invaluable for both beginners and experienced programmers.

37. Clean Code: Functions and Methods in TypeScript [Part 1]

Learn how to write cleaner code by avoiding common mistakes in functions and methods.

38. 4 Simple Habits For Engineering Teams To Beat Technical Debt

In the previous article, we looked at the macro trends that make tech debt inevitable. However, even though tech debt is a fact of life, technical bankruptcy doesn't have to be. So this time, let's look at the methods we can employ to avoid technical bankruptcy and save everyone a lot of grief, time, and money.

39. A Deeper Look into Clean Architecture: Flutter vs Kotlin

Flutter app vs Kotlin app. MVI Clean Code Freezd and Riverpod

40. AI Coding Tip 003 - Force Read-Only Planning

Set your AI code assistant to read-only state before it touches your files.

41. Keeping Your Code in Monorepo -Pros and Cons

42. Less Dirty Code

Clean Code is a Lie and Nobody Writes it.

43. Code Smell 260 - Crowdstrike NULL

Learn how to avoid the null trap in privilege mode drivers to prevent system crashes, security risks, and instability.

44. How to Find the Stinky Parts of Your Code [Part XX]: We have Reached 100!

We reached the 100th code smell!

45. How To Fail A Coding Interview

A parable about missed deadlines and over-engineering

46. NO!! GitHub Copilot Will NOT Steal Your Job

GitHub Copilot is not a threat for great software designers. Just a shortcut for lazy ones.

47. Building a Wordle Game Using Test-Driven Development in 25 Minutes

Developing a complete word game is very easy with TDD

48. Decouple Your Go Components by Leveraging Mediator and Event Aggregator Patterns

Decouple your Go components by leveraging Mediator and Event Aggregator patterns. Learn how to use open-source mediator / event aggregator library called mob.

49. Clean Code: Interface Segregation, Dependency Inversion, SOLID Principles in TS [Part 5]

Dive into the advanced concepts of clean code in TypeScript, focusing on the Interface Segregation Principle and Dependency Inversion Principle.

50. Code Smell 316 - The Syntax Police Review Anti-Pattern

Syntax-focused code reviews hide architecture flaws, waste human attention, and lower quality. Automating style checks lets teams review what truly matters.

51. The Typescript Quirks That Pushed me to Create a New Dependency Injection Library

The Typescript quirks that pushed me to reinvent the wheel by creating a new-brand Dependency Injection library for Javascript.

52. Code like You're Building a Lego Castle

The article compares coding to building a castle with Legos and emphasizes the importance of following best practices to avoid mistakes and build a sturdy code.

53. How to Find the Stinky Parts of Your Code (Part II)

There are more code smells. Let’s keep changing the aromas. We see several symptoms and situations that make us doubt the quality of our development. Let's look at some possible solutions.

54. The Dirty Code Problem: Improve Your Game with Good Naming Practices

The Rule: Whenever you name a variable, function, or class, ask if it is concise, honest, expressive, and complete.

55. How too Much Love for Your Code Can Hurt the Product

A story about how important it is to keep a smooth balance between complexity and simplicity while building software.

56. Code Smell 07 - Avoid Boolean Variables

Avoid Boolean variables, they lead to conditional logic and force you to write Ifs. Create polymorphic states instead

57. Clean Code: Naming and Code Composition in TypeScript [Part 2]

Learn best practices for writing clear, efficient, and readable code that saves time and enhances developer productivity.

58. Writing Clean Front End Code

Writing clean front end code for a resilient, readable front end code repository.

59. How to Find The Stinky Parts of Your Code (Part X)

More code smells. No joke. We see several symptoms and situations that make us doubt the quality of our development.

60. How to Write Clean, Well Maintained Code Using a Static Analyzer and PMD

A static analyzer can reduce the possibility of bugs, such as when you accidentally overwrite a variable with another value.

61. How to Find the Stinky Parts of Your Code (Part III)

There are yet more code smells. Let’s keep changing the aromas. We see several symptoms and situations that make us doubt the quality of our development.

62. Untangling Heavily Nested Python Code

Reducing the nesting level of code by applying a guard clause.

63. I Wrote More than 90 Articles in 2021 and Here is What I Learned in a Nutshell

This article summarizes my experience as a writer during the pandemic year 2021

64. Code Smell 252 - NullCustomer

65. How to Write Clean Code and Save Your Sanity

Learn how to write clean code that will save you time, headaches, and sanity. This article covers practical strategies & tools to help you elevate your coding.

66. Mastering RxJS Memory Leaks: The Leak Detective Handbook

Memory leaks happen when Observables linger around in memory, long after they’ve finished their tasks. They’re no longer needed, but they stick around anyway, t

67. 6 Awesome Tips To Help You With CSS Selectors

Choosing the right CSS selectors can be a lot of trouble and there’s so much information out there that it can even be a little overwhelming at times. Words like “combinators” and “specificity” get thrown around a lot, you read how greater specificity increases efficiency but then how ID’s (the most specific) should be avoided like the plague, according to some. What’s a poor coder to do as he navigates the cascading landscape of style sheets? Hopefully by the end of this I will have been able to outline some good practices, and provide enough additional resources, to clear this issue up for good.

68. How Clean Code is Lowering the Quality of Developers

I believe that software development has a problem with mis-promotion, and over-promotion of "Clean Code".

69. Leveraging Google's Pinject to Write Loosely Coupled Python Code

Dependency Injection(DI) is a set of software design principles that enable engineers to develop loosely coupled code. This stack overflow post is the best ELI5 description of DI:

70. Functional Programming Paradigm in JavaScript

There’s nothing new about Functional Programming. Functional Programming has been around for much longer than OOP as it dates back to the 60s.

71. Code Smell 282 - Bad Defaults and How to Fix Them

Treat unknown responses as unauthorized, not as valid.

72. Code Smell 05 - Comment Abusers

Leave comments just for important design decisions. Don't explain the obvious.

73. How to Find the Stinky Parts of Your Code [Part XXXII]

It smells because there are likely many instances where it could be edited or improved. Most of these smells are just hints of something that might be wrong.

74. Clean Code: Functions and Error Handling in Go: From Chaos to Clarity [Part 1]

Learn how to write clean Go functions that pass code review. Practical patterns for single responsibility, error handling, and the defer statement from 6 years

75. Why is This So Hard?

This article explores what good code is and shares some tenets of good structure.

76. AI Coding Tip 008 - How to Use Spec-Driven Development With AI

Use AI to understand requirements and build a shared mental model while you write the code.

77. Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3]

Master Go interfaces: why single-method interfaces rule, accept interfaces return structs, and the nil interface gotcha that crashes production. From 6 years of

78. How to Find the Stinky Parts of Your Code [Part XXIV]

Most of these smells are just hints of something that might be wrong. They are not required fixed per se… (You should look into it though.)

79. From Helpful to Harmful: How AI Recommendations Destroyed My OS

Always stay in control when using AI tools. Blind trust can lead you to costly mistakes.

80. Creating a Strong Code Quality Culture in Your Organization

Learn how to build a culture of code quality to improve maintainability, scalability, and efficiency, and stay ahead of the competition.

81. Refactoring 014 - How to Remove IF

The first instruction you learned should be the least you use

82. How to Find the Stinky Parts of Your Code [Part XXII]

Most of these smells are just hints of something that might be wrong. They are not required fixed per se… (You should look into it though.)

83. A Hacker Tried to Steal $566M by Exploiting a Code Smell, Here's How

Yesterday, 2022 Oct 7th one of the larger blockchains had to be halted. This news was shocking since most blockchains are decentralized by definition.

84. Negating 'Side Effects' in Python: A Guide (With Pictures!)

A step-by-step guide on how to refactor side effects in your python code. Examples, pictures, and recipes on how to deal with dirty code with side effects.

85. The Myths and Realities of Bug-Free Code

86. Refactoring 031 - Removing OOPs

Replace vague error messages with specific, actionable feedback that helps users solve problems.

87. Clean Code for Python – Stop Writing Bad Code

Learn key principles from 'Clean Code' by Uncle Bob and apply them to Python. Write clean, readable, and maintainable code with simple yet effective changes.

88. AI Coding Tip 006 - Review Every Line Before You Commit

If you can't explain all your code, don't commit it.

89. Writing clean code: Naming

Code is read more than it is written. To write code we are constantly reading it. Here are 8 rules for writing cleaner code based by choosing better names.

90. How to Setup SonarQube Locally Using Docker

I will explain how you can set up SonarQube locally with docker.

91. AI Coding Tip 001 - Commit Your Code Before Asking For Help From an AI Assistant

Commit your work with a clear message like "feat: manual implementation of X."

92. Code Smell 12 - Null is Schizophrenic and Does Not Exist in The Real-world

Programmers use Null as different flags. It can hint at an absence, an undefined value, en error etc. Multiple semantics lead to coupling and defects.

93. Hack Your Technical Debt: The 1% Better Every Day Challenge

It's easy for technical debt to grow in our codebase. Commit to spending 20 minutes a day for 30 days to tackling technical debt and get 1% better every day.

94. How to Find the Stinky Parts of Your Code [Part XXX]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

95. Clean Code: Structs, Methods, and Composition Over Inheritance [Part 2]

Write cleaner Go code. Learn how structs, methods, and composition replace OOP inheritance the idiomatic Go way.

96. Implement This One Cultural Characteristic to Build A Healthy Codebase

It’s easy to pay lip service to company culture. But few companies actively consider those few cultural characteristics that make a meaningful difference to performance—because that’s the hard part.

97. Changing Keys, Losing Values

When you use mutable objects as keys in hashed collections, changing them breaks contracts.

98. How to Find the Stinky Parts of Your Code [Part XXVII]

Identifying smells in your code and debugging the easy way.

99. How to Find The Stinky Parts of Your Code (Part IX)

Yet more code smells? Aren't them enough?

100. How to Find the Stinky Parts of Your Code [Part XLVI]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

101. Step by Step Wordle Creation With Codex AI

I transcribe the instructions to create a working wordle using natural language.

102. Refactoring 021 - Remove Dead Code

Eliminate unused functions, constants, and "just-in-case" code.

103. Code Smell 236 - What to Do With Excessively Long Code Lines

In this article, I will shed light on the code smell associated with neglecting proper line wrapping and explore why it's considered bad practice

104. Code Smell 293 - You Should Avoid Adding isTesting or Similar Flags

When you add flags like isTesting, you mix testing and production code. This creates hidden paths that are only active in tests.

105. Refactoring 027 - How to Remove Getters

Remove or replace getters with behavior-rich methods that perform operations instead of exposing internal state.

106. Write Cleaner Code with My Top 5 JavaScript Hacks

107. Code Smell 318 - Wasting Time Refactoring Dirty Code

Don't waste time refactoring code that never changes; focus on frequently modified problem areas.

108. Small Commits, Big Wins: How Atomic Changes Transform Developer Life

Learn how atomic Git commits transform developer productivity. Discover practical strategies for cleaner code reviews, faster debugging, and painless deployment

109. Maxi Contieri on Clean Code, Refactoring, and Test-Driven Development

I blog about clean code, refactoring and TDD. I have been working on the industry for the past 25 years

110. 4 Ways Software Engineers Organize Their TODOs

TODOs are a tricky subject for developers. Many codebases are guilty of having TODOs linger around while nobody knows who’s responsible for a TODO or even has the required context to tackle it. Yet, should we feel ashamed for our lingering TODOs?

111. How to Find the Stinky Parts of Your Code [Part XXVI]

How to debug your code the easy way

112. Code Smell 08 - Send Messages Only to Your Direct Acquaintances, Not Their Friends

Send messages only to your direct acquaintances, not their friends.

113. How to Find The Stinky Parts of Your Code [Part XII]

More code smells for your reading pleasure

114. How to Find the Stinky Parts of Your Code [Part XVI]

The most beautiful code, the most beautiful functions, and the most beautiful programs are sometimes not there at all.

115. How to Find the Stinky Parts of Your Code [Part XLVII]

Finding the stinky parts of your code--debugging and programming help for software developers.

116. Refactoring 008 - Variables That Never Change Should Be Constants

Be explicit on what mutates and what doesn't.

117. How to Find the Stinky Parts of Your Code [Part XIX]

New code smells arriving!

118. How to Find the Stinky Parts of Your Code [Part XXI]

Code smells are a classic. It smells because there are likely many instances where it could be edited or improved.

119. Is Dry Code Still Relevant Today?

120. Let's Stop Calling them 'Bugs' - Software Quality is Our Responsibility

The term Bug sounds like an excuse out of our scope infecting our systems. It is not. Software quality is under our control. It is our responsibility to deliver

121. If Your Documentation Takes Two Clicks to Open, Congrats - It’s Already Outdated

An article on effective documentation practices in software development, explaining how to structure specs, READMEs, JavaDocs, and clean code.

122. The Code Is the Documentation; a Paradox That Rings True

The first time I heard someone say: “the code is the documentation”, I thought it sounded completely wrong, like a lazy excuse for not producing documentation.

123. How to Name Things Properly

Perhaps it is not news to everyone that there are two hard things in Computer Science.

124. We Should Get Rid of "Hello, World!" Forever💩

Every tutorial I've read for the last 30 years starts with the infamous 'Hello World' example. This could be one of the reasons we write crappy software.

125. Python — Duplicate For Loops

While developing a program, duplicate pieces of code may occur as a result of choosing of particular data structures.

126. Code Smell 307 - Naive Time Assumptions and How to Fix It

Time is not absolute. Your code breaks when you treat it that way.

127. How to Find the Stinky Parts of Your Code (Part V)

Are we done on code smells? Probably never!

128. Y2K22: The Problem that Caused Millions of Emails Worldwide to go Undelivered

The Y2K22 Bug is the consequence o very bad software design

129. How to Find the Stinky Parts of Your Code [Part XXXIX]

It smells because there are likely many instances where it could be edited or improved.

130. Top Coding Principles To Live By

I want to share basic concepts on how to write robust and good maintainable code. They will allow you to write better and more maintainable code.

131. Everything You Need to Know About Dead Code

A practical guide to identifying, understanding, and safely cleaning up dead code to keep your codebase fast, clean, and maintainable.

132. Code Smell 238 - Dealing With Entangled Code

Learn practical solutions to common Python code problems related to readability and scoping.

133. Code Smell 308 - The Key to Safer, Cleaner, More Polymorphic Code

Avoid methods that return Object, Any, or null instead of specific types. Make them fully polymorphic

134. How to Find The Stinky Parts of Your Code (Part VI)

Are we tired with code smells? Not yet!

135. 5 Ways to Prevent Server Hardware Failure

Use mature tools to make mature software

136. The Art of the Prompt: Engineering GenAI to Produce SOLID-Compliant Code

Generative AI writes code that works, but not code that lasts. Prompting with SOLID principles turns it from junior coder to senior architect.

137. Don't Mix Data Access Concerns With Essential Business Behavior

Passing databases creates accidental coupling and breaks business encapsulation.

138. Code Smell 271 - The Hollywood Principle

The [Hollywood Principle] is a software design principle emphasizing loose coupling between components.

139. Getting the Best Out of Code Reviews

Explore the intricate balance of art and science in code reviews. Dive into techniques for effective feedback, and a collaborative culture.

140. How to Find the Stinky Parts of Your Code [Part XVIII]

More code smells incoming

141. How to Find The Stinky Parts of Your Code [Part XI]

This another code smell chapter

142. Is "Agentic Programming" the Next Big Shift?

In 2025, the developer's role is shifting from a manual "writer" to a strategic "orchestrator," managing teams of digital agents that can self-correct.

143. How to Find the Stinky Parts of Your Code [Part XXXIII]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

144. How to Find the Stinky Parts of Your Code [Part XLIV]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

145. Your First Line of Defense for Clean Code is Pre-Commit: How to Set It Up

This article describes pre-commit, a framework for managing and running git hooks to automate code quality checks before code is committed.

146. How to Find the Stinky Parts of Your Code [Part XXV]

The smell of code smells is a classic, but you should look at it more carefully if you want to improve your code smell.

147. How to Find the Stinky Parts of Your Code [Part XXVIII]

Learn to fish out code smells and debug with ease.

148. The 6 Types of Code Refactoring That Every Programmer Should Know

Refactoring is the process of changing the current codes of software to make it easier to understand and maintain without modifying its internal functionality.

149. How to Find The Stinky Parts of Your Code (Part VIII)

Yet more code smells? Plenty of!

150. Clean Code: Package Architecture, Dependency Flow, and Scalability [Part 4]

Learn how to organize Go packages, avoid import cycles, structure scalable projects, and use interfaces and internal directories the right way.

151. Clean Code With AI

This is my talk at Tech Excellence on combining Artificial Intelligence and Clean Code

152. Code Smell 246 - Modeling Expiration Dates

In many systems, the expiry date of a credit card is often represented by simply using a Date object. This can lead to potential issues and misunderstandings.

153. Here's the 7-Step Framework I Use to Get Ahead in Automation Testing

Today, I’ll share seven best practices that transformed my testing mayhem into a lean, mean, bug-busting machine.

154. Stop "LGTM" Culture: How to Turn Code Reviews into a Masterclass with AI

Stop treating AI as just a code generator. Use this system prompt to turn it into a relentless, educational, and ego-free code auditor.

155. Code Smell 313 - “Workslop” in AI-Assisted Programming

Stop shipping AI workslop. Learn to spot plausible-but-wrong code, restore domain intent, and refactor machine output before it becomes tech debt.

156. Track & Manage Your Technical Debt To Make Better Strategic Decisions

If you are looking for a tool to start managing technical debt this article will help you make the right decision.

157. Comments, Naming, and Abstractions in the AI Era

AI hasn't killed "Clean Code," but it has changed the audience.

158. How We Cut Chat UI Frame Time by 8% with One Jetpack Compose Optimization

Learn how switching from SubcomposeLayout to Layout in Jetpack Compose reduced Chat UI frame time by 8% with real benchmark data and code examples.

159. Flip the Script: Write the Tests, Let AI Write the Implementation

TDD is widely accepted as the gold standard for producing robust, reliable, and refactorable software.

160. The Meaning, Purpose and Benefits of Code Refactoring

In the article, we cover the topic of code refactoring and discuss the value of the process.

161. Code Smell 285 - How to Fix Non-Imperative Functions

Functions with unclear names hide intent and confuse readers. Use descriptive, action-oriented names.

162. How to Set Up a Team's Systems and Culture for Strong Code Reviews

All software companies must take an intentional and structured approach to code reviews. Here are some tips on how to do that.

163. Replace Sequential IDs in Your Models With UUIDs to Prevent IDOR Vulnerabilities or Scraping

When you model your identifiers with real-world concepts rather than database rows, you avoid exposing accidental implementation details.

164. How to Find The Stinky Parts of Your Code [Part XV]

We see several symptoms and situations that make us doubt the quality of our development. Most of these smells are just hints of something that might be wrong.

165. Why I Switched to Table Driven Testing approach in Go

Table driven tests, also known as parameterized tests, have became very popular over the past few years due to their ability to eliminate repetition.

166. Java Lambda Functions: Your Secret Weapon Against Boilerplate Code

Discover the power of Java lambda functions and how they eliminate boilerplate code. Explore cool use cases, save time, and write more expressive code.

167. Learn How To Use Git Submodules on Practice

In this post we learn about concept of Submodules in git by actually troubleshooting a case of embedding multiple git repositories

168. AI Coding Tip 010 - Access All Your Code

Use terminal-based AI tools to give your assistant direct access to your local files and test suites.

169. Elevating Software Quality: A Guide to Effective Code Reviews

Explore advanced code review techniques to boost software quality, featuring AI, gamification, and industry case studies.

170. Code Refactoring Tips: No. 015 - Remove NULL

Eliminating The Billion-Dollar Mistake forever - Discover how the Null Object Pattern can streamline your code by eliminating the need for null checks.

171. How to Find the Stinky Parts of Your Code [Part XL]

Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.)

172. Refactoring 024 - Replace Global Variables with Dependency Injection

Replace global variables with dependency injection to improve testability and reduce coupling.

173. Refactoring 013 - Eliminating Repeated Code with DRY Principles

Learn how to eliminate repeated code, enhance maintainability, and create a single source of truth with our DRY (Don't Repeat Yourself) principles.

174. Code Smell 304: Null Pointer Exception - How to Avoid NULL References That Cause Runtime Crashes

Avoid NULL references that cause runtime crashes by using proper validation and null-safe patterns

175. Code Trashing Symptom

There are a set of skills and qualities which make the ideal software developer we are all searching to be or searching for to employ. However, right now I am going to emphasize the importance of a quality that is mostly found in senior developers.

176. Code Smell 270 - Boolean APIs

An API might have a secure parameter that enables additional security checks when set to true. While this approach seems simple, it introduces several problems.

177. Refactoring: Remove Setters #CodeSmell

Warning: Setters Considered Smelly

178. Refactoring 025 - Decompose Regular Expressions

You can break down a complex validation regex into smaller parts to test each part individually and report accurate errors.

179. Refactoring 020 - Transform Static Functions

How to replace static functions with object interactions.

180. Code Smell 259 - Control Your Environment to Avoid Test Failures

Learn how to prevent unreliable tests by generating or mocking test data, ensuring full control over the testing environment and avoiding external dependencies.

181. How to Find the Stinky Parts of Your Code [Part XLIII]

Your code smells because there are likely many instances where it could be edited or improved.

182. Misusing HTTP Status Codes Wrecks Your API Monitoring and Client Logic

Returning a successful HTTP status when the actual result contains an error confuses the API consumers.

183. Just Go Ahead and Test Your Project - Part 1

Here, I recommend reading articles about TDD (Test-Driven Development) and BDD (Behavior-Driven Development), which can evolve from this stage.

184. The "Comment" Fallacy: Why Self-Documenting Code is Still the Goal

In the bible of software engineering, Clean Code, comments are often characterized as failures to write expressive code.

185. Code Smell 303 - How to Prevent Breaking Existing Clients When You Make Changes

You should version your APIs to prevent breaking existing clients when you make changes

186. The Secret Weapon of Developers Who Want to Sleep at Night

Clean code is your secret weapon. It’s the key to fewer late-night debugging sessions, fewer headaches for your future self, and more time for yourself.

187. Programming Books May Be the Better Way to Learning to Code

Online tutorials are quick, but books build real depth. I’ll show you why reading is the secret to mastering code, and share 5 must-read programming books.

188. Here's Why You Should Replace Inheritance with Delegation

Replace restrictive inheritance hierarchies with flexible object delegation

189. Code Smell 309 - Query Parameter API Versioning

Maintain clear version documentation, test versions thoroughly, and deprecate old versions gradually. This practice will ensure that your API users are happy.

190. How to Find the Stinky Parts of Your Code [Part XXXI]

Beginners are afraid to remove code. And many seniors too.

191. Code Smell 10: Functions With Too Many Arguments

Passing too many arguments to functions hurts maintainability. Learn how to refactor parameters into meaningful domain objects.

192. Code Smell 315 - Cloudflare Feature Explosion

In the early hours of November 18, 2025, Cloudflare’s global network began failing to deliver core HTTP traffic, generating a flood of 5xx errors to end users.

193. How to Find The Stinky Parts of Your Code [Part XIV]

More smells on the way.

194. Code Smell 13 - Empty Constructors

Pass the essence to all your objects so they will not need to mutate.

195. Code Smell 274 - Cascaded Returns

Prevent chaining return statements for better code readability and flow.

196. Code Smell 268 - Ternary Metaprogramming

Ternary metaprogramming uses conditional operators to select and invoke methods dynamically. It leads to code that's harder to understand, debug, and maintain.

197. Code Smell 263 - Squatting

Resource squatting happens when attackers anticipate the naming patterns of cloud resources, like S3 buckets.

198. How to Find The Stinky Parts of Your Code (Part VII)

We see several symptoms and situations that make us doubt the quality of our development.

199. Code Smell 298 - How to Fix Microsoft Windows Time Waste

Skipping status reports in conditional branches causes silent delays and race conditions.

200. Overusing Implicit Returns Makes Your Code Harder to Read and Debug

Overusing implicit returns makes your code harder to read and debug.

201. AI Coding Tip 013 - Stop Wasting Tokens With Progressive Disclosure

You reduce token usage when you trigger conditional loading instead of loading all files at once.

202. 4 Ways to Destructure Array in JavaScript & Make Your Code Look Clean

Dive Deep into 4 ways of Array Destructuring Techniques and Elevate Your JavaScript Skills to the Next Level!

203. How to Find The Stinky Parts of Your Code [Part XIII]

We see several symptoms and situations that make us doubt the quality of our development.

204. Five Years Later: Clean Code Is Still Right (But Not Always Useful)

A reflection on clean code, five years later. What still holds up, what feels incomplete, and how experience changed how I think about cleanup.

205. Code Smell 265 - Linguistic Confusion

Overcomplicating naming conventions in code can lead to confusion, bugs, and frustration. Here's how to make your code easier to read and maintain.

206. Code Smell 243 - Concatenated Properties

If you use a separator to break the attributes, you need to make sure the separator does not belong to the domain, and you should escape it.

207. How to Find the Stinky Parts of Your Code [Part XXIII]

It smells because there are likely many instances where it could be edited or improved.

208. Refactor Like a Pro: Ditch Hardcoded Inputs for Good

That little input() call might seem harmless, but it's quietly sabotaging your ability to test, debug, and grow your project.

209. Code Smell 258 - The Dangers of Hardcoding Secrets

Use a secret manager to avoid hardcoding sensitive information.

210. An Interview With Maximiliano Contieri: Bridging the Industry-Academia Divide

In this episode, Maximiliano Contieri helps us understand the longstanding tension between academia and industry from an insider’s perspective.

211. Refactoring 007 - The Refactor That Reveals Missing Concepts

Put together what belongs together.

212. Object Design Checklist: An Index on Software Design Articles

Important concepts about Object-Oriented Programming

213. Code Smell 255 - Addressing Parallel Hierarchies in Code

Addressing redundant code structures: Learn to identify, simplify, and refactor parallel hierarchies to reduce duplication and improve maintainability.

214. Code Smell 239 - Big Pull Request

You make too many different changes in a single pull request.

215. 3 Things Coding And Prose Writing Have In Common According To Cory House

Does your code read like a book?

216. Code Smell 273 - Overengineering

Overengineering complicates your code with unnecessary abstractions and complexity. Learn how to simplify your code using the KISS principle.

217. Code Smell 09 - What Should You Do With Dead Code?

Do not keep code "just in case I need it".

218. Code and the Art of Motorcycle Maintenance: Typical Rookie Faults

With coding, just like with riding, you need to be responsible and conscious to stay in the saddle and double that to be a winner.

219. Refactoring 022 - Extract Common Ancestor

Extract a common abstract class to mimic real-world structure.

220. Components Genesis: Mastering the Top-Down Code Design Approach

Learn how to write reliable and professional-looking React code using "Wishful Programming" aka "Top-Down Code Design". Great for coders of all levels.

221. Brace Yourself: Data Cleanup is Coming

It goes without saying that data is the cornerstone of any data analysis.

222. Code Smell 242 - Zombie Feature Flags

Discover the pitfalls of feature flags in software development, from the dangers of dead code to unnecessary complexity.

223. The Lack of Internal State and How it Makes Your Classes Easier to Test and Refactor

You likely often hear that test-driven development (TDD) or just writing tests can make your code better.

224. Code Smell 287 - Unused Local Assignment

Avoid assigning values you never use.

225. Refactoring 037 - Testing Private Methods

You can and should test private methods without using AI.

226. Refactoring 032 - Apply Consistent Style Rules

When machines generate large amounts of code, you need to apply one consistent style to all files.

227. How to Find the Stinky Parts of Your Code [Part XXXVIII]

It smells because there are likely many instances where it could be edited or improved.

228. Code Smell 06 - Trying to Be a Clever Programmer

Don't try to look too smart. Clean code emphasizes readability and simplicity.

229. How to Implement the Visitor Pattern Correctly

Avoid combining the Visitor pattern with instanceof checks.

230. Comments: The Good, the Bad and the Ugly

I don't believe comments are failures, but rather a tool that, when misused, can hinder more than help. As we'll see, some comments are extremely useful.

231. Code Smell 283 - Unresolved Meta Tags

Incomplete or null meta tags break functionality and user experience.

232. How to Prevent Your Code From Turning Into Sausage That Goes Beyond the Screen

Today, we'll talk about a bug that shows in practice how "code sausage" can cause a series of problems related to the last line effect

233. Adding Source Attribution to Question Answering Systems

Without source attribution, even the most accurate system risks losing user trust.

234. Code Smell 261 - DigiCert Underscores

In digital certificate validation, missing an underscore prefix can lead to significant issues, as seen with DigiCert’s recent problems.

235. Understand the Intent of Patterns And Principles Before Applying Them

TL;DR;

236. How to Avoid Code Smells - A NDepend Tutorial

.NET developers can evaluate and visualize the codebase using the robust static analysis tool NDepend. It aids programmers in understanding the quality and main

237. Code Smell 277 - UPPERCASE Acronyms

Treat acronyms like normal words to improve human readability.

238. Code Smell 290 - Refused Bequest

Subclasses should honor ALL their parent’s contract.

239. Code Smell 245 — Exec() and Eval()

Don't use metaprogramming. It is not that cool.

240. How to Find the Stinky Parts of Your Code [Part XXXVI]

Coding tutorials to help you in your coding life.

241. When You Forget to Throw, Your Code Will Blow

Creating a new exception without throwing it leads to silent failures.

242. Premature Memoization: How to Properly Apply It - Code Smell 250

Memoization can help you improve the performance of recursive functions involving redundant computations but compromise code readability and maintainability

243. Keep Your Happy Path Flowing, Not Nesting

Arrange your code so the main logic flows along the left margin, handling edge cases early with guard clauses.

244. Code Smell 264 - Hanlon's Razor

Overthinking and overdesigning your code can lead to unnecessary complexity. Learn how.

245. To Err is Human, to Test is Divine

We are humans, we forget, we make mistakes, we change things, ideas; This happens when we work solo, imagine when you are in a team!

246. How to Find the Stinky Parts of Your Code [Part XXXVII]

It smells because there are likely many instances where it could be edited or improved.

247. Domain Driven Design - The Basics

DDD gives us a framework for a way of aligning business with technology throughout the whole project lifecycle.

248. Code Smell 240 - Dead Store Code

Learn how to detect and address dead store code smells with expert tips.

249. Prompt Engineering for Senior Devs: Scaling Excellence Without Technical Debt

This guide explores the specific prompt engineering patterns senior devs use to generate boilerplate, unit tests, and documentation.

250. Code Smell 03: Functions Are Too Long - Here's How to Fix That

Refactor and extract functions longer than 5 lines. Here's how.

251. Code Smell 267 - Objects Aliasing

Discover the importance of using immutable objects in programming to prevent unexpected changes, reduce bugs, and improve code predictability.

252. Refactoring 016 - Building With The Essence

Pass essential attributes during object creation to reduce mutability and eliminate getters and setters.

253. Code Smell 299 - How to Fix Overloaded Test Setups

Bloated setup that's only partially used makes your tests more coupled and harder to understand.

254. Refactoring 030 - How to Avoid Accidental Redundancy

Identify methods that receive owned attributes
Remove those parameters from the method signature
Replace usage with direct access to the attribute

255. Code Smell 297 - Syntactic Noise

Stop writing cryptic code! Learn how to reduce syntactic noise, improve readability, and make your software easier to maintain and debug.

256. How to Find the Stinky Parts of Your Code [Part XLII]

Your code smells because there are likely many instances where it could be edited or improved.

257. Code Smell 300 - Package Hallucination

Avoid hallucinated or fake packages that can compromise security and stability.

258. Clean Code and Speed: Not Either/Or

Refuting claims that clean code hurts performance, this article shows how proper design delivers speed without sacrificing maintainability.

259. Code Smell 278 - DirName and File

Learn how to avoid ambiguous variable names like 'file' and 'dirName' in your code.

260. 6 Examples to Differentiate Desirable Technical Debts From Undesirable Ones

Technical Debts have been in the center of software engineers debate for quite some time. Not only its analogy to financial terms has been discussed, but also the different contexts and aspects a debt contains.

261. Code Smell 262 - Not Replaced Constants

A major security flaw, PKfail, persisted unnoticed for 12 years, compromising hundreds of devices.

262. Code Smell 275 - Missing Test Wrong Path

This article highlights the critical need for fail conditions in tests expecting exceptions.

263. Refactoring 035 - Use Separate Exception Hierarchies for Business and Technical Errors

Use separate exception hierarchies for business and technical errors.

264. Code Smell 286 - Parent-Child Method Overlaps

Avoid using private methods in parent classes with names that child classes can use.

265. Refactoring 033 - Removing Redundant or Unused Annotations

Make your code simpler and more maintainable by removing redundant or unused annotations.

266. Dev Diary #2: Run Away from Nesting Functions in Your Code

Discover how the Orchestrator/Actions Pattern can simplify your codebase, making it easier to navigate, test, and maintain.

267. Code Smell 254 - Be Explicit

Be explicit when creating tests to ensure clarity and maintainability.

268. Code Smell 257 - Simplifying Property Names By Removing Prefixes

Avoid using prefixes on collections whenever possible.

269. Build Scalable Products by Coding for Future Feature Expansion

How to build scalable products by coding for future feature expansion & code deprecation while maintaining a simplified user interface for complex functionality

270. Code Smell 272 - API Chain

Use primitive steps to verify API behavior instead of direct requests.

271. Finding the Stinky Parts of Your Code: Code Smell 256 - Mutable Getters

Avoid mutable getters to protect your code's integrity and encapsulation. Learn how to return immutable copies in Java for safer and more predictable coding

272. Refactoring 017 - Convert Attributes to Sets

Using sets for attributes simplifies your code and makes state management easier.

273. Code Smell 310 – Why Generic Date Names Break Your Code

Use descriptive date names that reveal their role and business purpose instead of generic "date" labels.

274. Code Smell 279 - Loop Premature Optimization

Don't optimize loops without a clear need and concrete real-world evidence

275. The Mighty App Developer vs a Pesky Bug

A year ago, I, the almighty mobile application developer, was brought down by a pesky bug that was causing my precious creation to crash frequently for users.

276. Code Smell 284 - Encrypted Functions

Discover why cryptic code hurts readability, security, and trust in your software.

277. Code Smell 241 - Referential Transparency Violation

Learn how to write pure functions to enhance code readability, maintainability, and testability.

278. Code Smell 04 - Stop Abusing Strings—Use Real Objects Instead

Use real abstractions and real objects instead of accidental string manipulation.

279. Code Smell 292 - Missing Return

Missing return statements cause unexpected behavior.

280. Code Smell 269 - Low-Level Addition

Learn how declarative code improves readability and maintainability by simplifying logic and reducing verbose loops.

281. Refactoring 034 - Wrapping Messy Parameters Into a Single Meaningful Entity

Wrap messy parameters into a single meaningful entity.

282. Code Smell 244 - Incomplete Error Information and How to Fix It

You show an error and provide no useful information

283. How to Find the Stinky Parts of Your Code [Part XLV]

Your code smells because there are likely many instances where it could be edited or improved. Most of these smells are just hints something might be wrong.

284. Code Smell 266 - Collection Aliasing

Learn why using immutable collections in Java is crucial for avoiding unpredictable behavior and unintended side effects.

285. Code Smell 253 - Silently Truncating Your User Data Without Warning

If you limit text lengths, enforce them everywhere!

286. Top 10 C++ Open Source Project Bugs Found in 2019

Another year is drawing to an end, and it's a perfect time to make yourself a cup of coffee and reread the reviews of bugs collected across open-source projects over this year. This would take quite a while, of course, so we prepared this article to make it easier for you. Today we'll be recalling the most interesting dark spots that we came across in open-source C/C++ projects in 2019.

12/3/2024: Top 5 stories on the HackerNoon homepage!

1/27/2026: Top 5 stories on the HackerNoon homepage!

289. Navigate Debugging Challenges with These Proven Techniques

290. How to Find the Stinky Parts of Your Code: 249 - Constants as Numbers

You map concepts to optimized numbers.

291. Replace AI References in Comments with Tests That Actually Work

You reference external AI conversations to explain code instead of writing declarative tests

292. Why You Must Start Refactoring Your Codebase Today

What is refactoring? Why do we go through the trouble of improving code that works?

293. Code Smell 02 - Don’t Let Mysterious Numbers Rule Your Code

Avoid Magic numbers without explanation. You don't know their source and are very afraid of changing them.

294. Code Smell 237 - Attribute Definitions Guide

295. How Dyslexia Shapes The Way I Code

Dyslexia has shaped how I read and write code, influencing my preference for structured, easy-to-scan formatting.

296. How To Find the Stinky Parts of Your Code: Code Smell 248 – Unreliable Copy

Discover the importance of verifying file copies to prevent silent modifications and uphold software principles like the Least Surprise and Fail Fast principles

6/20/2025: Top 5 stories on the HackerNoon homepage!

9/1/2025: Top 5 stories on the HackerNoon homepage!

← Previous

232 Blog Posts To Learn About Cicd

309 Blog Posts To Learn About Clean Code

Let's learn about Clean Code via these 309 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.