Take a look into AWS' recently announced distributed Aurora SQL solution, now in preview!

An exploration on how Git Worktree makes stash redundant and saves you headaches across large changes.

Learn to express your thoughts and opinions better with this guide.

We look into implementing the Acquire and Release Pattern in TypeScript for creating a sequence of operations with compensating actions on failure.

In this blog post, we take a look at libraries such as EffectTS, Zod, Valibot and Joi to understand how they approach a Result-like type and how we could approach building our own.

We tie together everything that we've learned so far about Node.js streams and apply it through a practical example using the AWS CDK, AWS S3 and AWS Transfer Family.

We looking into the pipeline function from the Node.js stream module.

What are Transform streams in Node.js? How do they work? We cover the fourth and final fundamental stream type in this post.

What are Duplex streams in Node.js? How do they work? We cover the third fundamental stream type in this post.

What are Writable streams in Node.js? How do they work? What are some common use cases for Writable streams? We continue our exploration into streams in this post.

What are readable streams in Node.js? How do they work? What are some common use cases for readable streams? Let's explore these questions in this post.

Everything you need to prepare yourself to know Node.js Streams.

Learn what a Buffer is in Node.js, how to think about it and how it is useful.

Learn how we can use InversifyJS to help dependency injection with it's inversion of control container.

Go 1.22 comes a brand new built-in router option for more complicated server applications. This is a basic dive in for Golang first timers.

Ever wondered how design systems provide an 'as' prop for their components that you can use to inject or change the component type? Let's look at how we can do this with TypeScript.

After another failed hard drive meant losing data, I decided to look into mounting my own cloud storage. Here is how I did it.

This post is for you if you are migrating across from a Prisma application or just want to check out the performance difference with DrizzleORM.

Understand the Node.js profile flag by improving an inefficient approach to getting unique elements from an array.

One of the JavaScript ecosystems biggest pain points. What are they and why do library maintainers hurt inside when they have to support them all?

A walkthrough on setting up a basic Express.js application and writing tests using Supertest for robust APIs.

Join me as we dive deep into TypeScript's type operators, including keyof, index types, and index signatures. I'll be guiding you through practical examples that you can follow along with in the TypeScript Playground. Master these powerful tools with me to boost your TypeScript's code reliability and predictability with an advanced type system.

See how TypeScript is used with async promises.

Implement your own map function with TypeScript.

A practical explanation of how union and intersection types work.

This post covers the basics of modules in TypeScript.

See how we can use the TypeScript operator keyof to dig into our types.

A look at different implementations of generics for more specific use cases.

Decorators, a proposed feature for JavaScript, are already available as an experimental feature in TypeScript. See an example of decorators in action in this post exploring the topic.

Implementing custom type guards for a complex type validation with deep object structures.

Get started with the new Vercel AI SDK in this quick demo with NextJS.

Mapped types are a powerful feature that enable us to take existing types and generate new types from them on the fly.

See the T extends U ? X : Y syntax in action with simple examples.

Advanced Use Case: Exploring type inference with conditional types and more complex generic patterns.

Learn how you can statically generate pre-determined Next.js pages using a database for improved build times while still allowing for dynamic content to be generated on the fly.

Ever wanted to better understand the unknown type? This blog post walks you through a practical setup and look at working with the unknown type.

Following the release of Satori and Vercel's new open graph image generation, follow along as I demonstrate how I updated my own open graph images for the blog.

A look at implementing beautiful graph UI components quickly with Tremor.

This post focuses on my work at Visibuild to roll-forward a feature to a more scalable solution.

Peel back some of the magic behind discriminated union in TypeScript and how they impact your workflow.

Help understand your Rails models easier with the help of the annotate models gem.

Set up ActiveStorage on your local developer environment with Rails 7.

A short overview on how you can mock both class methods and instance methods when dealing with Minitest.

Some basic tips on getting more value from the Pry debugger.

A quick look at using the SmarterCSV gem.

See how you can use Sidekiq jobs to read and process a local YAML template for populating the database.

See how to upload files to ActiveAdmin using this example that uploads a CSV file and populates data to the database.

In the final part of the Ruby Gem series, we will be automating the deployment of our recently created gem using GitHub Actions.

In this post we will take our basic code from the previous exercises and package it up as a Ruby gem to install in other projects.

In part two of the Ruby gem series, we will take the gem we created in the previous part and deploy it to RubyGems.

In this short overview, see how MiniTest can be incorporated into your GitHub Actions workflows.

In this short overview, see how RSpec can be incorporated into your GitHub Actions workflows.

In this short post, see how you can visualize your domain model quickly using the rails-erd gem.

Following up on the previous post, we will be looking at the last through associations that come baked into Rails.

In part ten of the Devise series, we start a new project from scratch to explore how the devise-token-auth gem can be setup with a Rails 7 application.

In part eleven of the Devise series, we continue on with the previous project to add the capability of authenticating to a public API using authentication tokens with Doorkeeper.

In this post, we go through all six of the possible Rails associations with visualizations to help us understand what associations are supported and how they work in Rails 7.

This post is a reflection on my first look at using Ahoy analytics in a Rails 7 application.

ActiveAdmin is a powerful gem to help us generate admin panels for our internal usage for Rails applications. This post will cover the basics of getting up and running with ActiveAdmin and Ruby on Rails 7.

See how the FriendlyID gem makes it simple to convert you URLs into something more useful and friendly with Rails 7.

An intro into Ruby memoization with the memoization operator and the Memoist gem.

See how to setup SimpleCov for your RSpec tests in a simple Ruby setup and then implement a GitHub Action to comment the coverage results in a pull request.

For this part, we look at setting up some helpers for us to log users in when writing controller tests.

This post looks at how we outline required policies in order to fulfill requests in Ruby on Rails using the Pundit gem.

In part nine, we take a look at how we can set up our API endpoints to return a 401 response if a user is not signed in instead of the default 302 redirect to the login page.

This post will demonstrate how to benchmark and compare code to help us better understand the performance of our Ruby code.

In part five, we set up the OmniAuth configuration for Devise to demonstrate login using GitHub.

In part six, we enforce the usage of reCAPTCHA v2 to prevent signing up or logging in without passing the reCAPTCHA verification.

Follow the basics to send an email using a Postmark template and view it in the browser during development.

In part one of this six part series on Devise and Ruby on Rails, we demonstrate setting up Devise for Rails 7 with a basic sign up and login flow.

In part two of our Devise series, we look at how we can replace the default cookie session store with Redis.

In part three of the series, we walk through how to add TailwindCSS to a Rails 7 project and spruce up our sign in page.

In part four, we add in a separate Next.js project into the mix and demonstrate how to organize authentication for our main Rails API.

In the second of two posts, we look at setting up rate-limiting with the rack-attack gem to see how we can limit requests to our API.

This is the first of two posts that will look at rate limiting in Rails application. This post will focus on the rack-throttle gem and its usage with Redis.

A demonstration on getting a local development environment going with Sidekiq and Redis to run a simple demonstration job in Rails 7.

An entry-level introduction to setting up the Rails cache and seeing it in action with Redis in development.

Implement simple pagination mechanisms using the Kaminari gem with Ruby on Rails 7.

Continuing on from the last post, we introduce Redux to handle our remote messages and perform actions on our React.js application.

Dive head-first into using Action Cable with Rails 7 and setup a basic React project that can handle web sockets.

At this stage of the project, we are introducing Factory Bot to help replace the default fixtures so we can test our PostsRepository code.

Continuing on with our project, the next step is to add in dry-validation and dry-monads to help tidy up our code.

A look at how we can implement a Railsy-way of the Repository Pattern in our Rails apps.

See how we can use the Dry RB gems dry-matcher and dry-monads to clean up our Ruby code.

Follow along as we build out a skeleton Rails 7 server that enables us to use GraphQL.

Set up a new Rails 7 project with ESBuild that has TypeScript support out-of-the-box.

See how you can update your new Ruby on Rails 7 project to use HTM and React without a Node.js setup.

This guide will alleviate questions that new Rubyists have around monkey patching and how it works in Ruby.

Why the '!' in Ruby is so important to conquer and real-world implications.

Understand pattern matching in Ruby.

A recap on the fundamentals of Ruby blocks.

As 2022 kicks off, I am listing out the core principles that I am putting a focus into throughout the year.

An overview on Python higher-order functions, decorators and some practical examples for when decorators can be used.

Discover a great use case for Jest Snapshot testing with template engines and generators.

Generate fake data to be used in your applications based on a JSON schema document.

Use the ts-json-schema-generator package to generate a valid JSON schema from your TypeScript types.

Output DMBL files from your Prisma schema and see how you can view it online.

Create new Stripe subscription products from a simple TypeScript script.

Set yourself up for success in large Next.js project structures by following this opinionated layout.

I share 5 of the Figma plugins that sped up my workflow 10x.

Don't mind me, I am just testing my scheduled blog post workflow.

Reduce instances and costs for single-run cron jobs by using AWS EventBridge rules to trigger AWS Lambda functions.

Automate the process of creating shortened URLs for your Next.js posts with this how-to guide.

A recount on how I minted 2460 pieces of generated digital art onto OpenSea from my hotel room in Australia.

See how to use Jest alongside GitHub Actions run Jest testing in CI.

See how easy it is to build a TypeScript NPM package using Parcel 2.

Avoid dirty reads on highly contended cache resources in Node.js with the Redlock package.

The beginner's guide to how different forms of server and client caching work with Redis and React Query.

Following on from the previous post, we will take the interim data structure we scraped from the Apiary documentation website and reshape it into a valid OpenAPI JSON structure.

As we begin a new short series on Swyftx, we begin by getting up and running with your API keys and retrieving your profile with a simple Node.js project.

Using Puppeteer, we scrape the Swyftx API docs from Apiary and convert it into a JSON data structure to use later.

After 30+ days of my 100 day Python journey, I stop to reflect on the five tips that have been unusual by helpful coming into the language.

In our final coverage of regression using SciKit Learn, we look at how we can use regression with regularization.

In part three, we look at using k-fold cross-validation to prevent dependency on a particular train/test split.

In second blog post on linear regression, we take what we learned in part one and look deeper into the basics of linear regression and applying a train-test-split to our data.

This short recap on Kubernetes will set the foundation for the upcoming series on Kubernetes and EKS.

Continuing with our look into supervised learning, today we explore the basics linear regression by applying it to another Scikit Learn toy dataset.

See how we can visual test the performance capability of our K-Nearest Neighbors classifier using Scikit Learn.

The 34 Days of Python series is moving into its second phase with Machine Learning. The journey will start with a first look at project setup and classification.

Deploy a simple Python lambda function with the TypeScript AWS CDK to LocalStack.

Deploy a Kubernetes Fargate on EKS cluster using the AWS CDK.

Apply an oil paint effect to images in Python with OpenCV.

Learn how to use GitHub Actions to speed up your Pip package deployments to PyPi.

Use the ECS patterns library to deploy a simple Fargate cluster to LocalStack.

Learn how to generate random data and export it to CSV to use in your projects.

The second part of this demo will show how to interact with our DynamoDB table using DynamoDB Toolbox.

Use Conventional Commits, pre-commit and Commitizen to automate your versioning based on commit messages.

A walkthrough on how to deploy a local DynamoDB table to LocalStack with the AWS TypeScript CDK.

Learn how to deploy your first package to Pip in this straight-forward tutorial.

Use the TypeScript AWS CDK to deploy an S3 Bucket fronted by a CloudFront CDN and Route53 record.

Build off previous work on PyTest by adding a GitHub action to run PyTest in CI.

Explore PyDoc and understand how it can improve your documentation and how to search it.

Speed up your local AWS CDK development but using LocalStack and the AWS CDK Local wrapper package.

Get started with the AWS CDK in TypeScript and learn some of the foundational work for upcoming tutorials.

Explore how to work with the time module from the Python Standard Library in detail.

Learn how to set up reliable PyTest unit tests for the Python datetime library with FreezeGun.

Learn how to work with the datetime library in Python.

An overview look at custom exceptions in Python

This post will look at how the regex module in python can be used to work with regular expressions.

See how the Rich library for Python can make it easy to add color and style to terminal output.

Introduce yourself to MoviePy through a simple example to add text to video.

Make debugging Python errors more enjoyable.

Use PyInquirer to create more interactive and user-friendly command line prompts.

Display your public GitHub repositories in an interactive notebook.

Using the OS module recursively make folders on your operating system.

Learn the basics of installing and using PyTest with a basic math module example.

Work through an example of building a simple CLI script with the python-fire library.

A method to protect your Next.js routes from being accessed in production.

A Sunday morning product built to help be more public about my work and day-to-day life.

Use the glob library to create a list of all the files in a directory.

Learn how to take a markdown file and parse the frontmatter metadata for usage in your scripts.

Use the Pillow image library to add text and icons layers to an image programmatically.

Installing and using an unofficial Python Unsplash API by salvoventura

Setting up a Jupyter Notebook for the first time to aid with the 100 Days of Python challenge

Slowly introducing yourself to the world of generative art with this short introduction

Use the Node debugger to visualise performance

See how you can get started with the VSCode debugger for Node.js applications

An easy-to-understand example of how to run automated jobs using crontab on your Mac

Learn how to setup LocalStack to help with local development emulating AWS products

Learn how to play around with DynamoDB locally and use NoSQL Workbench to plan out your work

See how you can dynamically create UIs based on React State using dynamic imports, Next.js 10 and React State

Have you ever wanted to build a UI Component Library with TypeScript and React? This blog post will take you through a straightforward set up that uses the bare minimum to get a working component library that you can re-use across your different React projects.

This blog post will show you how I updated my Gatsby website to display a basic related articles section based on frontmatter tags.

This post will go through a simple example of setting up simple authentication with a user and password to your Next.js website.

This blog post will explore the new Next.js Image component for an optimised image experience on the web.

This blog post will explore the new internationalised routing in Next.js 10 and how you can use this to your advantage with react-intl for React.js

Learn how to create a test Stripe example, update that example and deploy to Vercel for a Stripe payment gateway, React 17, TypeScript 4 and Next.js 10

See a roundup of my look into Vercel's new analytics feature that you can enable on a Vercel project and see how I used GTMetrix to help push some numbers.

Learn how to deploy the base Next.js 10 app with the Vercel CLI and/or the Vercel GitHub Integration

Use the TypeScript AWS CDK to deploy static sites to S3 with a CloudFront distribution and Route53 setup for a custom domain.

Learn how to export static HTML from a Nextjs 10 project to host

Updating my previous post on using Create React App with Snowpack for the latest versions and NPM 7

Using Webpack 5 to build lambdas for AWS deployments

A look into how you can run a cron job to self-destruct tweets

Generate strongly-typed models and serializers from JSON, JSON Schema

Using TypeScript to standardise types across the board using JSON Schema

Prevent Breaking API Changes With OpenAPI And openapi-diff

Validate Your APIs With OpenAPI Schema Validator, YML and JSON

Explore a tool kit of models that you can apply to your own work day

Look at how you can create your first ESLint rule and apply it to a working application

Look at how we can work around one of the Service Worker's biggest misunderstanding

A quick overview of adding/retrieving secrets for AWS

Tips and tricks for how you can become the developer you've always wanted to be

Extend the Error prototype with ES6 classes to capture errors and send them to Sentry

A quick look at building a heat map in D3

Explore how redirection works in C

Use the React Context API with Tailwind's theme generator to access the values anywhere throughout the application

Get up and running with Tailwind faster than your bread takes to toast

Discover how the Skypack CDN can help use your favourite modules with Deno

Some learnings and reflections after hitting a month of sharing

Upgrade a CRA template to start making use of Snowpack

A look at named pipes and how we can interact with them in Golang

An evening project to speed up small, rough diagrams from the command line

See how we can auto-generate fully validated forms using React, Snowpack, YAML and a bit of grit

Tired of Twitter negativity? Avoid it all by posting from the safety of the command line!

Run through the basics to get your first Docker GitHub Action up and running

Understanding core functional programming concepts by implementing "pipe" and "compose" - two of the most common utility functions in JavaScript

This year has been... strange.

CSS is hard. In fact, I preach day in and day out that it one of the more difficult concepts to grasp effectively. Here are 7 tips to help you scale and manage CSS and its alternatives.

This tutorial covers setting up a project, writing a Go Lambda server using Gin, and deploying it with AWS CDK, providing detailed code examples and instructions.

Learn the lessons that I had to find out the hard way when it came to learning languages over and over and over...

A short example of setting up your first npm GitHub package

An entry-level look at how to setup determinstic Python environments using Pipenv

In this entry into Fiber, we will cover installation of Fiber, as well as the basics of GET + POST requests, handling errors and returning JSON.

A short morning run over setting up the factory_bot_rails gem with RSpec

In this example, we will screenshot vaild HTML with Puppeteer

Follow along as we do the bare minimum to start generating files using EJS from the command line

Improve your Design System with these websites that work as together as a foundation into your next UI iteration

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages!

Follow along as we go start to finish in setting up rate limiting on an ExpressJS server and show how to enforce it across multiple servers

Satirical Tech Lead Fridays

Use Next Auth to login into a Next.js application using GitHub Credentials, and store them in a local MySQL Docker container

How I built a local Alfred extension to quickly jump to the web page online

Using the Babel AST Parser to help find unused JS/TS/Less/SCSS files in the code base

Get up and going with Electron by using Parcel to handle the bundling, TypeScript for type checking, React for the UI and the Electron dialog API to help read/write files

Follow along to send a simple message to Slack by using the AWS SDK to trigger a JavaScript Lambda function on a timed cron job that has NPM dependencies required.

Use Nodejs and Xray to scrape the blog website

Use tmuxinator to setup projects that require complex setups

Use Node.js and Octokit to programatically create a markdown file in a GitHub repo

A short look at some important algebra properties and their formulas

Follow as I use functional Ruby programming to generate an OpenAPI v3 yml file from information given from rails routes and import it into Postman

Challenges and process to get the blog converted over to Gatsby + Netlify CMS

An overview of network addressing and how to understand concepts like network masking.

A quick overview on the seven layers of the Open System Interconnection (OSI) model.

A quick overview on the seven layers of the Open System Interconnection (OSI) model.

A short look at the data types available when using Scala.

Looking at usage of the web "fetch" API. This example uses the node-fetch library for demonstration purposes.

Looking at usage of the web "fetch" API. This example uses the node-fetch library for demonstration purposes.

A short look at how to sum an integer list and manipulate a string list using Java 8 streams.

A look into the common terms and their definitions when using Apache Kafka.

A look at ElasticSearch and setting up a multi-node cluster using Docker compose and create a JavaScript client for insertions.

A small intro into how you can get started with Cassandra using Docker and basic syntax.

A quick look at how RxJS implements an autocomplete subscription.

A quick overview of a number of programming paradigms and what are some key defining features.

A quick and dirty intro into the applications of numpy, pandas, sklearn and matplotlib to apply basic logistic regression.

Looking at how we can normalise data using the d3-scale library.

The tl;dr reminder of how Reselect works for Redux state memoization.

tl;dr Syd => Melb.

Go implementation of a Binary Search Tree.

A deeper look into processes under the hood.

Creating a D3 word cloud from a base Create React App project.

Creating queues to schedule workers using Kue.js, Node.js and Redis

An introduction to what EKS is.

Adding Redux Persist to React Native for data persistence.

Python implementation of comparing two strings to check if they are anagrams.

An introduction into managing packages on Kubernetes with Helm.

A look into how threads operate.

A short look into B-Tree structures, what defines them and some technologies that use them.

A basic look at how to add Istio to your EKS cluster.

An introduction to React Hooks.

The classic FizzBuzz implementation in Rust with Unit Testing.

Ruby implementation of a basic node tree and traversal using DFS and BFS.

How to setup Detox to run e2e tests for an Expo application.

PHP implementation of a Binary Search Tree.

Golang implementation of a basic node tree and traversal using DFS and BFS.

Java implementation of a basic unidirectional Linked List.

Ruby implementation of a Binary Search Tree.

JavaScript implementation of comparing two strings to check if they are anagrams.

Go implementation of a basic unidirectional Linked List.

Python implementation of a Binary Search Tree.

JavaScript Spiral Matrices with unit testing.

Setting up a MySQL container for local development.

Basic usage and command calls for Redis from the command line.

Python implementation of a basic node tree and traversal using DFS and BFS.

A basic intro to using the Redis chart and installing it with Helm.

Adding credentials to be used for EKS when pulling images from Docker Hub.

Basic intro to anonymous functions with PHP.

Basic instructions on how to use EKSCTL on the command line.

Basic applications of slices.

How to build instances with Ruby.

Basic error handling with exceptions in Python.

Building instances with PHP classes.

Java Spiral Matrices with unit testing.

Basic unit testing for PHP.

How to create basic lambda functions in Java requiring interfaces.

Linking two Docker containers to run a Nodejs app behind a NGINX reverse proxy.

A quick look at Ruby Lambda and Proc functions.

Basic string manipulation in Golang using the strings package.

Basic push, pop, shift and unshift applications for PHP.

PHP implementation of a basic unidirectional Linked List.

Basic implementation of maps in Java.

Using the arrays and array list utility packages in Java.

See what I do when it comes to JavaScript logging for web.

Create a basic payment with Braintree using React and Nodejs!

Simple basics on a GET and POST request for Gin in Go.

An introduction to React Portals.

Checkout how to create dynamic diagrams using mermaid!

Golang Spiral Matrices with unit testing.

Examples on how to handle errors in Ruby.

Example of adding in Amplify

Short introduction and link to the MyRocks engine.

Solution in Java.

Solution in Java

Suggestions and guides for naming in JavaScript.

Resources for log-structured merge trees.

A look at current base principles.

A small intro into auto-determining WCAG color contrast standards

What do you do when your content becomes super long?

Say hello to an easy way to parse CLI args and options with yargs parser.

Ruby implementation of a basic unidirectional Linked List.

Use the incredible Sharp package for Node and build a simple CLI image compression tool.

The classic FizzBuzz implementation in Golang with Unit Testing.

See example code on how to debounce trailing and leading events.

An introduction to React Context.

See example code for dynamically importing a React Component.

Python Spiral Matrices with unit testing.

PHP implementation of a basic node tree and traversal using DFS and BFS.

Python implementation of a basic unidirectional Linked List.

Ruby implementation of comparing two strings to check if they are anagrams.

PHP implementation of comparing two strings to check if they are anagrams.

An example of a simple health check for Kubernetes.

The classic FizzBuzz implementation in Ruby with Unit Testing.

PHP Spiral Matrices with unit testing.

The classic FizzBuzz implementation in Python with Unit Testing.

Ruby Spiral Matrices with unit testing.

How to use the Expo API to log into Facebook and authenticate on AWS Amplify.

The classic FizzBuzz implementation in Java with Unit Testing.

The classic FizzBuzz implementation in JavaScript with Unit Testing.

The classic FizzBuzz implementation in PHP with Unit Testing.

Blog initiation and hazing. Read my primary objectives with this blog and the series I will write about.