Posts

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.

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

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.

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.

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

Open-closed Principle

The ‘O’ in SOLID design principles is for the Open-Closed Principle. The gist of it is that any class or module should be open for extension but closed for modification. In other words, it should be possible to add new behaviour to a system without modifying its existing code. One of the key benefits of adhering to the open/closed principle is that it promotes the development of flexible and maintainable code.

Monday, January 16, 2023 Read

Single Responsibility Principle

The ‘S’ in SOLID design principles is for the Single Responsibility Principle. It is also the easiest one, in my opinion. The gist of it is that every part of the system should have only a single responsibility, including the system itself. Take the below code public class User { public void ActivateUser() { // Logic goes here } public void DeleteUser() { // Logic goes here } public void MailUser() { // Logic goes here } } On the surface, this looks fine, but those methods’ logic is neither reusable nor easily refactored.

Sunday, January 15, 2023 Read

Implicit Usings CSharp 10

To get things started, let’s make a clear distinction between .net 6.0 and C# 10. Though they come out bundled simultaneously, their versioning is distinct. Where are my using statements? With version 10 of C#, we also get Implicit Usings. In the simplest of terms, this means that you no longer have to spend time thinking about which namespaces to include in your application, you can start coding and the namespaces will implicatively be included.

Tuesday, November 29, 2022 Read

Thoughts on the Airpods Pro 2nd Gen

First impressions I enjoy headphones, headphone technology, and all it entails. This includes earphone tech and how it’s all being brought together. The original Apple Airpod Pros were my favourite wireless earbuds for many reasons. When Apple announced the second generation I was intrigued, Apple wouldn’t bring something out unless it was an upgrade on the original, right? Either way, I bought a pair to find out and…I was impressed!

Sunday, October 30, 2022 Read