Clean Code & Design Patterns Certification

Module 1: Foundations of Clean Code

• Clean code principles
• Code readability
• Maintainability
• Simplicity
• Developer responsibility
• Characteristics of quality code

Module 2: Meaningful Naming

• Variable names
• Function names
• Class names
• Naming conventions
• Intention-revealing names
• Avoiding misleading names

Module 3: Writing Clean Functions

• Small functions
• Single responsibility
• Function arguments
• Side effects
• Abstraction levels
• Function organisation

Module 4: Clean Classes & Objects

• Class responsibilities
• Encapsulation
• Class size
• Object behaviour
• Cohesion
• Maintainable class design

Module 5: Formatting & Code Organisation

• Code structure
• Vertical formatting
• Horizontal formatting
• Logical grouping
• Source file organisation
• Consistency

Module 6: Comments & Documentation

• Effective comments
• Unnecessary comments
• Self-documenting code
• API documentation
• Documentation maintenance
• Documentation practices

Module 7: Error Handling

• Exceptions
• Error boundaries
• Meaningful error messages
• Exception design
• Failure handling
• Error-handling practices

Module 8: Code Smells

• Duplicate code
• Long methods
• Large classes
• Long parameter lists
• Feature envy
• Common warning signs

Module 9: Refactoring Fundamentals

• Refactoring principles
• Extract method
• Rename techniques
• Simplifying conditions
• Removing duplication
• Incremental refactoring

Module 10: Managing Technical Debt

• Technical debt concepts
• Causes of technical debt
• Business impact
• Debt identification
• Prioritisation
• Debt reduction strategies

Module 11: SOLID – Single Responsibility Principle

• Responsibility
• Reasons for change
• Class decomposition
• Separation of concerns
• Practical applications
• Common violations

Module 12: SOLID – Open/Closed Principle

• Extension
• Modification
• Abstraction
• Extensible design
• Practical applications
• Common violations

Module 13: SOLID – Liskov Substitution Principle

• Substitutability
• Inheritance design
• Behavioural contracts
• Type relationships
• Practical applications
• Common violations

Module 14: SOLID – Interface Segregation Principle

• Interface design
• Small interfaces
• Client-specific interfaces
• Dependency reduction
• Practical applications
• Common violations

Module 15: SOLID – Dependency Inversion Principle

• High-level modules
• Low-level modules
• Abstractions
• Dependency injection
• Loose coupling
• Practical applications

Module 16: Coupling & Cohesion

• Coupling concepts
• Cohesion concepts
• Loose coupling
• High cohesion
• Dependency management
• Modular design

Module 17: Introduction to Design Patterns

• Design pattern concepts
• Pattern terminology
• Pattern categories
• Problems and solutions
• Pattern selection
• Pattern limitations

Module 18: Factory Method Pattern

• Object creation
• Factory methods
• Product interfaces
• Extensibility
• Implementation structure
• Use cases

Module 19: Abstract Factory & Builder Patterns

• Abstract Factory
• Families of objects
• Builder pattern
• Complex object construction
• Pattern comparison
• Practical applications

Module 20: Singleton & Prototype Patterns

• Singleton concepts
• Controlled instances
• Prototype pattern
• Object cloning
• Appropriate usage
• Common pitfalls

Module 21: Adapter & Facade Patterns

• Adapter pattern
• Interface compatibility
• Facade pattern
• Simplified interfaces
• Legacy integration
• Practical use cases

Module 22: Decorator & Composite Patterns

• Decorator pattern
• Dynamic behaviour
• Composite pattern
• Object hierarchies
• Flexible structures
• Pattern selection

Module 23: Proxy & Bridge Patterns

• Proxy pattern
• Access control
• Bridge pattern
• Abstraction separation
• Implementation flexibility
• Practical applications

Module 24: Strategy Pattern

• Strategy objects
• Algorithm selection
• Runtime behaviour
• Composition
• Eliminating complex conditions
• Practical use cases

Module 25: Observer Pattern

• Publisher-subscriber model
• Event notification
• Observer relationships
• Loose coupling
• Event-driven design
• Practical applications

Module 26: Command & State Patterns

• Command pattern
• Encapsulating requests
• State pattern
• State transitions
• Behaviour management
• Pattern comparison

Module 27: Template Method & Iterator Patterns

• Template Method
• Algorithm structure
• Iterator pattern
• Collection traversal
• Reusable behaviour
• Practical applications

Module 28: Testing Clean & Pattern-Based Code

• Unit testing
• Testable design
• Dependency isolation
• Mocking concepts
• Refactoring with tests
• Regression prevention

Module 29: Selecting & Combining Design Patterns

• Problem analysis
• Pattern selection criteria
• Combining patterns
• Avoiding overengineering
• Pattern trade-offs
• Maintainability considerations

Module 30: Refactoring Legacy Code with Design Patterns

• Legacy code assessment
• Identifying code smells
• Applying SOLID
• Selecting suitable patterns
• Incremental restructuring
• Improving maintainability