Coding

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

Sudoku Part 3

Last time, I wrote a fairly simple Sudoku puzzle generator. The only problem was that we had no way of determining solution uniqueness. So for the next part, that’s exactly what I want to do. Feel free to follow along at https://github.com/Wallyza/sudoku. I’ll also be tagging the repo as I go so that what you’re reading is aligned with what you see in the code. Today’s tag is 0.0.2: https://github.com/Wallyza/sudoku/tree/v0.0.2 Why uniqueness is important If a puzzle doesn’t have a unique solution, the ambiguity will likely end up in the player being stuck in a position where they’d need to guess. Personally, I want to solve puzzles using logic, elimination, and inference. Guessing reminds me of the very difficult Winmine puzzles back in the day, it’s not a good experience.

Tuesday, March 28, 2023 Read

Sudoku Part 2

In the previous part, I outlined what the plan was. In this part, we’ll be stepping into some code. Feel free to follow along at https://github.com/Wallyza/sudoku. I’ll also be tagging the repo as I go so that what you’re reading is aligned with what you see in the code. Today’s tag is 0.0.1: https://github.com/Wallyza/sudoku/tree/v0.0.1 How to run the code I’ve coded it up in .Net 6, I was too lazy to install 7. To run it you’ll have to install the SDK which can be found here: https://dotnet.microsoft.com/en-us/download/dotnet/6.0 along with installation instructions. Once it’s installed and you’ve cloned the repo, just navigate to the Sudoku project folder and run dotnet run.

Saturday, March 11, 2023 Read

Sudoku Part 1

What is this about I am quite fond of Sudoku as a quick past-time that helps my brain disconnect a bit and refocus. I have apps on my phone and on my PC that I can fire up when I feel like it. Only there is a caveat, there are some variations on Sudoku such as Chess Sudoku and Killer Sudoku and I haven’t really found one app that contains all which means having to pay for multiple apps.

Monday, March 6, 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. When a request comes in, the first object in the chain is given the opportunity to handle the request. It evaluates whether it can handle this request.

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. Add behaviour to an object without having to create a new derived class. Modify the behaviour of an object dynamically, while keeping the code maintainable and scalable. Let’s see it in action We start with our usual Animal base class

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

Dependency Inversion Principle

The ‘D’ in SOLID design principles is for the Dependency Inversion Principle. The gist of it is about decoupling the dependency of high-level modules from low-level modules. So that any changes in low-level modules don’t affect the high-level modules. When I first started coding my high-level modules (user interfaces) would heavily depend on the low-level modules (databases). If I ever wanted to switch to a different database provider it would involve moving the database, as-is, to the new infrastructure, due to these dependencies. Making changes to the database structure would also reflect those changes in code.

Friday, January 20, 2023 Read

Interface Segregation Principle

The ‘I’ in SOLID design principles is for the Interface Segregation Principle. The gist of it is that clients should not be forced to implement interfaces they don’t use. In other words, create interfaces that serve the client’s needs, instead of creating one general-purpose interface that attempts to serve all possible clients. This promotes the use of smaller, more focused interfaces which can be easier to understand and implement. In keeping with our zoo example, pretend we’re building a management system which would help the zookeepers in their day-to-day jobs. We would need those working with mammals to feed and walk the animals but fish don’t need to go for walks.

Thursday, January 19, 2023 Read

Liskov's Substitution Principle

The ‘L’ in SOLID design principles is for Liskov’s Substitution Principle. The gist of it is that objects of a superclass should be able to be replaced with objects of a subclass without altering the correctness of the program. In keeping with our zoo program, if we have a Bird class with a Fly() method, what happens to flightless birds? According to the LSP, if a program is written with a list of “Bird” objects and a “Penguin” object is added to the list, the program should still work correctly without any modification.

Tuesday, January 17, 2023 Read