Join today
Write your awesome label here.
Writing Clean Code: 20 Code Smells and How to Get Rid of Them
Learn to identify and eliminate 20 critical code smells that plague software projects. Master the design principles and refactoring techniques that separate maintainable code from fragile, hard-to-change systems. Transform your development skills with hands-on training in writing code that scales.
Write your awesome label here.
73 Lectures
Comprehensive Knowledge
6 Hours
Video Duration
20+ Labs
Focus on Practice
Course Certificate
Validate Your Learning
Course Contents
01
Introduction
This section provides an introduction to the course on writing clean code and demonstrates how to navigate the code examples contained in the repository. It covers the foundational importance of understanding code smells and introduces the resources and tools available for exploring different code examples and their solutions.
Introduction
Navigating the Code Base
Note on Code Smells
Course Resources
Let's Stay Connected!
02
Fundamentals of Software Design and SOLID Principles
This section covers fundamental design principles that form the foundation for writing clean code, including information hiding, encapsulation, abstraction, polymorphism, and deep modules. It then introduces the five SOLID principles which are essential guidelines for creating maintainable and extensible software.
Fundamentals of Good Software Design
Designing Deep Modules
SOLID Principles: Single Responsibility Principle
SOLID Principles: Open/Close Principle
SOLID Principles: Liskov Substitution Principle
SOLID Principles: Interface Segregation Principle
SOLID Principles: Dependency Inversion Principle
03
Code Smell: Repeated Switches
This section discusses the problem of identical switch statements or conditional chains appearing in multiple locations throughout a codebase. The focus is on understanding why repeated conditional logic creates maintenance nightmares and how polymorphism and encapsulation can eliminate this duplication.
Repeated Switches - Overview
Repeated Switches - Code Example
Repeated Switches - Solution Walkthrough
04
Code Smell: Primitive Obsession
This section addresses the code smell of primitive obsession, which occurs when developers rely exclusively on primitive types instead of creating custom types to represent domain concepts. It demonstrates how custom types enable encapsulation and reduce knowledge duplication.
Primitive Obsession - Overview
Primitive Obsession - Code Example
Primitive Obsession - Solution Walkthrough
05
Code Smell: Loops
This section addresses the code smell of using explicit loops in code, which adds unnecessary complexity and obscures logic. It demonstrates how pipeline operations and functional approaches can abstract away iteration details and make code more concise and maintainable.
Loops - Overview
Loops - Code Example
Loops - Solution Walkthrough
06
Code Smell: Long Parameter List
This section explores the problems created when functions require many parameters, particularly when including flag parameters that merely determine conditional execution paths. The discussion covers maintenance challenges, type safety issues, and refactoring strategies including data object parameters and polymorphism to eliminate conditional branches.
Long Parameter List - Overview
Long Parameter List - Code Example
Long Parameter List - Solution Walkthrough
07
Code Smell: Knowledge Duplication
This section addresses the code smell of knowledge duplication, which occurs when the same logic is repeated across multiple places in the codebase. It demonstrates how extracting duplicated knowledge into shared functions or modules improves maintainability while avoiding over-extraction of unrelated code.
Knowledge Duplication - Overview
Knowledge Duplication - Code Example
Knowledge Duplication - Solution Walkthrough
08
Code Smell: Uninformative Comments
This section discusses the code smell of uninformative comments, which are comments that state the obvious rather than explaining the reasoning or intent behind code. It emphasizes that good comments should capture domain knowledge and usage intent while avoiding redundancy with the code itself.
Uninformative Comments - Overview
Uninformative Comments - Code Example
Uninformative Comments - Solution Walkthrough
09
Code Smell: Shotgun Surgery
This section addresses the code smell of shotgun surgery, which occurs when changes to one component require modifications in multiple unrelated places. It demonstrates how high coupling to internal data structures and semantic knowledge creates this problem and how encapsulation provides the solution.
Shotgun Surgery - Overview
Shotgun Surgery - Code Example
Shotgun Surgery - Solution Walkthrough
10
Code Smell: Alternative Classes with Different Interfaces
This section addresses the code smell of alternative classes with different interfaces, which occurs when similar classes have different methods for performing the same functionality. It demonstrates how establishing common abstractions through interfaces enables substitutability and reduces code duplication.
Alternative Classes with Different Interfaces - Overview
Alternative Classes with Different Interfaces - Code Example
Alternative Classes with Different Interfaces - Solution Walkthrough
11
Code Smell: Refused Bequest
This section examines the problem of subclasses inheriting methods and fields from parent classes that they don't actually need or use. The discussion covers how this represents poor inheritance hierarchy design and how composition often provides better alternatives than forcing unrelated types into the same inheritance structure.
Refused Bequest - Overview
Refused Bequest - Code Example
Refused Bequest - Solution Walkthrough
12
Code Smell: Data Clumps
This section addresses the problem of related data that is always used together but not encapsulated into a single object. The focus is on recognizing when multiple parameters or fields logically belong together and how to group them into proper abstractions that encapsulate behavior and reduce duplication.
Data Clumps - Overview
Data Clumps - Code Example
Data Clumps - Solution Walkthrough
13
Code Smell: Middle-Man
This section identifies the problem of middleman classes that merely delegate calls to dependencies without adding meaningful logic or behavior. The discussion covers how such classes increase coupling and complexity without providing real value, and explains when it's appropriate to remove intermediaries or consolidate functionality.
Middle-Man - Overview
Middle-Man - Code Example
Middle-Man - Solution Walkthrough
14
Code Smell: Mutable Data
This section addresses the problematic practice of modifying data structures in place rather than returning new instances with changes. The focus is on understanding why mutation creates difficult-to-track bugs, hidden dependencies between code parts, and how to adopt immutable or copy-based approaches for safer code.
Mutable Data - Overview
Mutable Data - Code Example
Mutable Data - Solution Walkthrough
15
Code Smell: Feature Envy
This section identifies the problem of functions that rely too heavily on other modules to complete their work, indicating low cohesion and misplaced responsibilities. The discussion covers how to recognize when functionality belongs in different locations and how to reorganize modules to reduce coupling and improve maintainability.
Feature Envy - Overview
Feature Envy - Code Example
Feature Envy - Solution Walkthrough
16
Code Smell: Divergent Change
This section addresses the code smell of divergent change, which occurs when a single entity needs to be modified for multiple unrelated reasons. It demonstrates how this violates the single responsibility principle and shows how splitting entities by responsibility reduces the reasons for change.
Divergent Change - Overview
Divergent Change - Code Example
Divergent Change - Solution Walkthrough
17
Code Smell: Large Interfaces
This section discusses the problematic pattern where modules expose too many public methods, leading to information leakage, increased coupling between components, and difficulty maintaining code quality. The focus is on identifying when interfaces become unnecessarily large and strategies for breaking them down into properly bounded, more focused abstractions that serve clear domain responsibilities.
Large Interfaces - Overview
Large Interfaces - Code Example
Large Interfaces - Solution Walkthrough
18
Code Smell: Multitaskers
This section addresses the code smell of multitaskers or functions that do multiple things, which causes them to be harder to understand and less reusable. It clarifies that the problem is not length but rather handling multiple unrelated responsibilities within a single entity.
Multitaskers - Overview
Multitaskers - Code Example
Multitaskers - Solution Walkthrough
19
Code Smell: Unclear / Confusing Names
This section addresses the code smell of unclear names, which occurs when variable and method names do not clearly convey their purpose or content. It emphasizes that meaningful names reduce cognitive load and eliminate the need to constantly refer back to declarations and usage contexts.
Unclear Names - Overview
Unclear Names - Code Example
Unclear Names - Solution Walkthrough
20
Code Smell: Speculative Generality
This section addresses the problem of adding functionality that isn't needed right now but is anticipated for future use. The discussion emphasizes how speculative features add unnecessary complexity and waste resources, while advocating for simple designs that remain flexible and easy to extend when actual requirements emerge.
Speculative Generality - Overview
Speculative Generality - Code Example
Speculative Generality - Solution Walkthrough
21
Code Smell: Unnecessary Exceptions
This section discusses the problem of throwing exceptions when reasonable default behaviors or values could be used instead. The focus is on understanding how unnecessary exceptions interrupt program flow, complicate code, and create boilerplate handling, and how sensible defaults can make code simpler and more resilient.
Unnecessary Exceptions - Overview
Unnecessary Exceptions - Code Example
Unnecessary Exceptions - Solution Walkthrough
22
Code Smell: Shallow Modules
This section addresses the problem of modules with large interfaces that provide simple or shallow functionality, resulting in complexity without corresponding benefit. The focus is on creating deep modules where simple interfaces hide meaningful complexity, and on eliminating shallow modules that add little value.
Shallow Modules - Overview
Shallow Modules - Code Example
Shallow Modules - Solution Walkthrough
23
Conclusion
This section wraps up the course on writing quality software by reviewing the core design principles covered throughout the material. It emphasizes the importance of recognizing common warning signs of poor design and understanding not just how to fix them but why they occur.
Congratulations and thank you!
Certificate of Completion
Frequently asked questions
Who is this course designed for?
This course is designed for multiple technical roles and career stages.
Software Engineers and Developers who want to write better code and advance their careers will learn to recognize the subtle design issues that make code hard to change and maintain. You will gain practical techniques to refactor existing code and make better design decisions in new code from day one.
Technical Leads and Senior Engineers responsible for code quality will discover systematic approaches to mentor junior developers, establish code standards, and recognize when architectural decisions create unnecessary complexity. You will understand not just what good design looks like but how to communicate why poor design matters to your team.
Software Architects and Technical Stakeholders evaluating code quality and maintainability will gain the vocabulary and frameworks to assess codebases, identify structural problems, and guide refactoring efforts. You will understand how design decisions early in a project compound over time.
Developers Transitioning to New Roles who want to succeed in positions with higher technical expectations will build the foundational knowledge required to work effectively in teams with strong engineering standards.
What prior knowledge do I need before taking this course?
You should have practical experience writing code in any object-oriented or functional programming language. Basic familiarity with concepts like classes, functions, interfaces, and inheritance will help you follow the examples.
No prior knowledge of design patterns, SOLID principles, or software architecture is required. The course builds your knowledge from the ground up, starting with foundational concepts and progressing through increasingly sophisticated design challenges.
How are the code examples structured so I can follow along?
Each code smell is presented in three parts. First, you see the problematic code and understand the issues it creates. Second, you learn the specific refactoring techniques to fix the problem. Third, you see the improved code and understand why it is better.
The course uses Git branches to organize examples. You can check out different branches to see before-and-after versions of code, making it easy to compare changes and understand the transformation. The repository includes clear instructions on navigating the examples using standard Git commands and IDE features.
Will I be able to refactor existing code with these techniques?
Yes, absolutely. The refactoring techniques covered in this course are designed to be practical and applicable to existing systems. You will learn how to improve code incrementally without requiring a complete rewrite.
Each section includes concrete refactoring steps that show exactly how to move from problematic code to improved code. You will understand how to identify the scope of changes needed and how to refactor safely in a way that maintains functionality while improving design. These are the same techniques used by professional development teams to gradually improve their codebases while continuing to deliver features.