Design Patterns

Singleton Pattern

Explore the Singleton pattern in C#. Learn with code examples.

Sunday, July 14, 2024 Read

(Short) Why are design patterns so great?

In the world of software engineering, design patterns are like the elegant blueprints that architects follow when constructing a skyscraper. They offer a structured approach to solving complex technical problems, making code more robust and maintainable. Let’s dive into why design patterns are essential for tech enthusiasts: 1 - Scalable Architectures: Design patterns, such as the Singleton or Factory Pattern, help us design scalable and extensible software architectures. They provide a solid foundation for growth without excessive refactoring.

Thursday, November 9, 2023 Read

Circuit Breaker Design Pattern

Introduction One of my personal favourite patterns, the Circuit Breaker Design Pattern, is used to prevent an application from repeatedly trying to execute an operation that is likely to fail. This can lead to performance degradation, system failure, or missed data. In this post, I’m going to discuss the Circuit Breaker Design Pattern in detail, including its purpose, how it works, and its benefits. Purpose of the Circuit Breaker Design Pattern The purpose of the Circuit Breaker Design Pattern is to provide a way to handle errors and failures in distributed systems.

Sunday, September 10, 2023 Read

Claim Check Pattern

The basics When we’re working in event-driven architecture we have to take care to maintain size-efficient payloads as they move between our micro-services. This is doubly important when we’re working with sensitive data (like PII) and we need to keep that data ring-fenced. This is where Claim Check saves us. What we’re essentially doing is taking any large or sensitive data and ri~~~~ng-fencing it behind security and authentication. The data will have an identifier and whenever a service requests data for that specific identifier, the Claim Check service can supply that data, thus hydrating models and recording access requests (should the requirement exist).

Saturday, August 26, 2023 Read

Observer Pattern - Efficient Event Handling

In the realm of software design, one pattern stands out for its ability to facilitate robust communication and interaction between components: the Observer Pattern. This pattern is a cornerstone of many successful software architectures, allowing developers to create decoupled, flexible systems that react dynamically to changes. In this blog post, we’ll delve into the essence of the Observer Pattern, its key components, benefits, and real-world applications. Overview The Observer Pattern is a behavioural design pattern that establishes a one-to-many relationship between objects.

Tuesday, August 15, 2023 Read

The Observer Cat Pattern - A Tribute to Atlas

I wanted to publish this post right next to my Observer Pattern post, as a tribute to an awesome cat we had to say goodbye to this week. I thought I’d celebrate the little guy’s life through the lens of the Observer Pattern. If you’re trying to learn more about the actual Observer Pattern, give it a read here: Observer Pattern The Observer Pattern and Your Cat In this particular pattern, you serve as the subject and your cat as the observer.

fun

Tuesday, August 15, 2023 Read

Blue-Green Deployments - What Are They and Why Are They Important?

Introduction With all the higher-level patterns I wanted to go back to basics a little bit and look at Blue-Green deployments. Though it can be deemed a design pattern (we’d certainly have to keep it in mind when we design our application), it’s probably more of a deployment strategy. What is a Blue-Green Deployment? A blue-green deployment is a software deployment strategy that involves creating two identical production environments, one for the current production release (blue) and one for the new release (green).

Monday, July 31, 2023 Read

Ambassador Pattern

Understanding the Ambassador Pattern for Distributed Systems Distributed systems can offer a range of benefits, including improved scalability, better fault tolerance, and increased flexibility. However, designing and managing distributed systems can be challenging, particularly when it comes to ensuring that services can communicate with one another effectively. This is where the Ambassador Pattern comes in. What is the Ambassador Pattern? The Ambassador Pattern is a design pattern that provides a decoupling mechanism between services in a distributed system.

Sunday, July 23, 2023 Read

Sidecar Design Pattern

The Sidecar Pattern: A Lightweight Approach to Microservices Introduction I’ve been looking at the ambassador pattern recently and it seemingly plays well with the sidecar pattern but before I just started implementing I thought I’d do some digging to better understand both and jot my findings here. With the advent of microservice architecture, developers face the challenge of managing the complexity that comes with the interoperability of it. The sidecar pattern is here to make things a little bit easier.

Sunday, July 16, 2023 Read

Chain of Responsibility Design Pattern

The Chain of Responsibility is a behavioural design pattern that allows a request to be passed down a chain of objects, each of which can decide whether or not to handle the request. This is useful when you have a group of objects that can handle a request differently, and you want to allow each object to handle the request before giving up. The idea is to create a chain of objects, each of which has a reference to the next object in the chain.

Friday, March 3, 2023 Read

Decorator Pattern

I wanted to start the series out with the decorator pattern. It’s straightforward and helps maintain SOLID principles by allowing us to extend classes instead of modifying them. Definition The Decorator pattern allows behaviour to be added to an individual object, either statically or dynamically, without affecting the behaviour of other objects from the same class. It is used to: Enhance the functionality of an object at run-time by wrapping the object with additional behaviour.

Wednesday, February 1, 2023 Read

Introduction to Design Patterns

I want to write several articles based on specific design patterns, but I thought I should first explain what they are. Not to be confused with Design Principles, Design Patterns are reusable solutions to common problems that arise in software design. It’s that simple. Developers can also use it to help understand decisions made in code. They provide a way to structure code to make it more maintainable, reusable, and scalable.

Monday, January 30, 2023 Read