Posts

(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

Expanding on Unit Tests with GenFu and ChatGPT

In this chapter on unit testing, I’m going to discuss Moq and how it can effectively be used to ensure you are unit testing correctly without having to concern yourself (too much) with dependencies further down the chain. In this final (for now) chapter on unit testing, I’ll be showing you how to generate randomised data for our unit tests using GenFu as well as how we can use ChatGPT to write unit tests for us.

Tuesday, October 31, 2023 Read

Using Moq to complement your Unit Tests

In this chapter on unit testing, I’m going to discuss Moq and how it can effectively be used to ensure you are unit testing correctly without having to concern yourself (too much) with dependencies further down the chain. Sample Project I’ve used the base ASP.NET Code Web API project to start things off and made a few modifications to it, all of which can be found in the repo below: https://github.com/Wallyza/EasyTests/tree/v2.0

Sunday, October 22, 2023 Read

Unit Testing in C# with FluentAssertions

Unit testing should be an essential part of your SDLC, especially when you have multiple contributors to a project. It’s a great way to ensure that your code is still returning the appropriate responses, even after someone else (who might have a different context than you) has tinkered with it. Don’t get me wrong, writing unit tests can be an exercise in tedium but it has saved my behind more times than I care to admit. There are tools to make things a bit easier though and I’ll go through a couple of them over the next few posts and end with a bit of a secret weapon (hint: it’s ChatGPT).

Tuesday, October 10, 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. It is essential to have a mechanism in place to handle these errors because they can cause cascading failures that can bring down an entire system. The Circuit Breaker Design Pattern provides a way to detect and handle these errors in a way that is both safe and efficient.

Sunday, September 10, 2023 Read

Windows Terminal with Oh My Posh

I spend a considerable amount of my time in the terminal, a large portion of that doing things with version control. As such I find it handy to have as much information available at a glance. On Ubuntu and MacOS I use Oh My Zsh, a great plugin to extend and customise your terminal but what happens when I’m working on Windows? Thanks to Oh My Posh we can customise our Windows Terminal to have similar extensibility and customisation.

coding
fun

Saturday, September 2, 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. In this relationship, when one object (the subject) changes state, all dependent objects (the observers) are notified and updated automatically. This enables efficient communication and synchronisation between components without tightly coupling them together.

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. In much the same way as a regular observer, your cat (in my case Atlas) would attach their interest in your state and react according to that state change.

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). Traffic is initially routed to the blue environment. Once the green environment is tested and ready, traffic gets switched over to green. Now intense monitoring takes place, we’re talking people glued to Grafana dashboards watching for things like exceptions, abnormal performance spikes, etc.

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. This pattern is particularly useful in cases where a service needs to access another service that is running on a different network and is not directly accessible.

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