Posts

All the articles I've posted.

• Design Patterns: Null Object

  Published:Oct 1, 2022 |  at 03:34 PM

  This article discusses the Null Object design pattern, explaining how it can be used to simplify code by removing the need for null checks. It covers the impact of null checks on cyclomatic complexity and provides a practical guide to implementing the pattern for cleaner and more maintainable code

• Design Patterns: Template Method

  Published:Sep 24, 2022 |  at 04:32 PM

  The Template Method pattern defines an algorithm's structure in a base class while allowing subclasses to customize specific steps. This approach reduces code duplication, enforces workflow consistency, and supports better extensibility, making it ideal for scenarios like game logic, UI frameworks, and data processing.

• Design Patterns: Memento

  Published:Sep 17, 2022 |  at 12:18 PM

  The Memento Design Pattern, a powerful tool for implementing undo/redo functionality and managing object states while adhering to software design principles like encapsulation and the Single Responsibility Principle.

• Design Patterns: Bridge

  Published:Sep 10, 2022 |  at 03:09 PM

  The Bridge pattern decouples abstractions from their implementations, enabling flexible and scalable code structures. By favoring composition over inheritance, it helps manage complexity and reduce code duplication.

• Design Patterns: Command

  Published:Sep 3, 2022 |  at 02:06 PM

  The Command design pattern encapsulates actions as objects, allowing for flexible execution, queuing, and undo/redo operations. It decouples command execution from application logic, enhancing modularity and maintainability in systems

• SOLID: Dependency Inversion Principle

  Published:Aug 27, 2022 |  at 03:20 PM

  The Dependency Inversion Principle (DIP) promotes decoupling by ensuring high-level modules depend on abstractions, not low-level details. This leads to more flexible, maintainable, and testable code, often implemented through Dependency Injection.

• SOLID: Interface Segregation Principle

  Published:Aug 20, 2022 |  at 05:33 PM

  The Interface Segregation Principle (ISP) advises that objects should only depend on the interfaces they actually use, promoting smaller, cohesive interfaces over large, cumbersome ones. By adhering to ISP, you reduce coupling, enhance code maintainability, and improve testability, ensuring that clients aren't burdened with unnecessary methods.