All posts

Series Tags

Valuable functional programming basics every developer should know

With many new programming languages seeing the benefits of being multi-paradigm it is becoming increasingly valuable to understand the basics of them all

Migrating your project from Java to Kotlin

Sharing some experiences around migrating a project focusing on tricks to make it easier and traps to avoid.

Wrapping primitives in domain objects

It is easy to enjoy primitive obsession when managing domain objects but we should always consider wrapping these into their own class to make a clearer and more developer friendly codebase

Common traps to avoid when using feature toggles

Feature toggles are a great tool but can easily be misused. In this article I go through some of the poor uses of feature toggles that have made them a bit more painful than useful

Introduction to Layered Architecture

An introduction to the layered architecture approach for organizing software projects

Why you no longer need feature branches

An introduction to feature toggles/flags and the benefits of using them over feature branches

Speed up your Gitlab pipelines to Heroku

Some useful techniques to improve or create a CD pipeline for Heroku deployment from Gitlab

Kotlin class validation in initialization

Kotlin introduces a different syntax for initializing a class over Java. When we had some validation in the constructor the migration may be a little difficult.

Exploring how to use the Law of Demeter

The Law of Demeter promotes loose coupling in our code, I have always struggled to find its value though but once I did I wanted to share my examples.

Don't fret over it not being perfect

In software we should be accept and utilize that we do not need to have our solution perfect before we can even write our first line of code

Making it Immutable

What is immutability and how it can help your development

Intro to the basics of TDD

Introduction to some of the basic concepts of test driven development

Making your own test doubles and mocks

Exploring the difference between test doubles/mocks and stubs. In particular looking at how we can make them without a framework

Why would I even use dependency injection?

A short walkthrough of dependency injection and why you should use it

Deploying Micronaut Application to Heroku

Deploying your hobby Micronaut projects

Managing Local Heroku Deployments

Likely overkill to ensure you know what you have deployed

How was I so wrong about CI and what I learnt about CD

Looking into exactly what is the whole notion of CI vs CD vs CD

Making microservices in Rust

Trying out some of the frameworks currently available in Rust to put together a microservice

Note Taking in Visual Studio Code

How you can set up VSCode to be a useful note taking application rather than getting another application just dedicated for notes.

Writing Rust Documentation

A simple reference for Rust documentation of your own crates.

Binding Raspberry Pi Libraries

Tackling two main areas that Rust has greatly simplified. Binding to C/C++ libraries and cross compiling for embedded systems (or not too embedded in terms of the Raspberry Pi)

Cross Compilation for Rust (Windows on Linux)

Looking into how to compile Windows binaries on a Linux machine for Rust.

Simple GUI in Relm

Relm is a GUI framework built off GTK and looked like a great candidate for my first Rust GUI program.