ComputerScience

C# Fluent Validation

Fluent Validation has been around for a long time and if applied correctly it can seriously enhance your model validation.

Wednesday, March 19, 2025 Read

Angular Service Worker

PWAs have been around for ages and one of their biggest features is local caching done by a service worker. Let’s dive in and see how easy it is to implement one for Angular.

Sunday, March 9, 2025 Read

Diving into TOGAF

The Open Group Architecture Framework is one of the most widely used frameworks in use. Let’s dive into it a bit to better understand how this framework is structured.

Wednesday, August 28, 2024 Read

It’s often easy to overlook class modifiers when we’re coding in C#. I’ve found myself regularly simply flagging something as public for the sake of convenience. Class modifiers don’t end with public and private though. Let’s dig into some of the class and property modifiers we find in C# 12. Public public is an access modifier that allows access unrestricted. This class can be instanced anywhere, whether it’s inside the same namespace or not.

Monday, April 1, 2024 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:

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.

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.

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

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