An exploration on how Git Worktree makes stash redundant and saves you headaches across large changes. (8 min read)

Learn to express your thoughts and opinions better with this guide. (10 min read)

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

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. (22 min read)

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. (19 min read)

We looking into the pipeline function from the Node.js stream module. (11 min read)

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

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

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. (11 min read)

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. (11 min read)

Everything you need to prepare yourself to know Node.js Streams. (23 min read)

Learn what a Buffer is in Node.js, how to think about it and how it is useful. (12 min read)

Learn how we can use InversifyJS to help dependency injection with it's inversion of control container. (9 min read)

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. (8 min read)

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. (8 min read)

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

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. (6 min read)

Understand the Node.js profile flag by improving an inefficient approach to getting unique elements from an array. (11 min read)

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? (9 min read)

A walkthrough on setting up a basic Express.js application and writing tests using Supertest for robust APIs. (5 min read)

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. (4 min read)

See how TypeScript is used with async promises. (4 min read)

Implement your own map function with TypeScript. (3 min read)

A practical explanation of how union and intersection types work. (4 min read)

This post covers the basics of modules in TypeScript. (3 min read)

See how we can use the TypeScript operator keyof to dig into our types. (2 min read)

A look at different implementations of generics for more specific use cases. (4 min read)

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. (5 min read)

Implementing custom type guards for a complex type validation with deep object structures. (5 min read)

Get started with the new Vercel AI SDK in this quick demo with NextJS. (7 min read)

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

See the T extends U ? X : Y syntax in action with simple examples. (6 min read)

Advanced Use Case: Exploring type inference with conditional types and more complex generic patterns. (7 min read)

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. (9 min read)

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. (8 min read)

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. (6 min read)

A look at implementing beautiful graph UI components quickly with Tremor. (4 min read)

This post focuses on my work at Visibuild to roll-forward a feature to a more scalable solution. (24 min read)

Peel back some of the magic behind discriminated union in TypeScript and how they impact your workflow. (11 min read)

Help understand your Rails models easier with the help of the annotate models gem. (3 min read)

Set up ActiveStorage on your local developer environment with Rails 7. (4 min read)

A short overview on how you can mock both class methods and instance methods when dealing with Minitest. (4 min read)

Some basic tips on getting more value from the Pry debugger. (6 min read)

A quick look at using the SmarterCSV gem. (2 min read)

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

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

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

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. (2 min read)

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

In this short overview, see how MiniTest can be incorporated into your GitHub Actions workflows. (4 min read)

In this short overview, see how RSpec can be incorporated into your GitHub Actions workflows. (3 min read)

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

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

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. (4 min read)

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. (7 min read)

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. (9 min read)

This post is a reflection on my first look at using Ahoy analytics in a Rails 7 application. (4 min read)

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. (5 min read)

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

An intro into Ruby memoization with the memoization operator and the Memoist gem. (4 min read)

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. (5 min read)

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

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

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. (6 min read)

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

In part five, we set up the OmniAuth configuration for Devise to demonstrate login using GitHub. (7 min read)

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

Follow the basics to send an email using a Postmark template and view it in the browser during development. (13 min read)

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. (5 min read)

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

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. (4 min read)

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. (9 min read)

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. (10 min read)

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. (6 min read)

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

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

Implement simple pagination mechanisms using the Kaminari gem with Ruby on Rails 7. (9 min read)

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

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

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

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

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

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

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

Set up a new Rails 7 project with ESBuild that has TypeScript support out-of-the-box. (4 min read)

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

This guide will alleviate questions that new Rubyists have around monkey patching and how it works in Ruby. (9 min read)

Why the '!' in Ruby is so important to conquer and real-world implications. (3 min read)

Understand pattern matching in Ruby. (4 min read)

A recap on the fundamentals of Ruby blocks. (8 min read)

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

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

Discover a great use case for Jest Snapshot testing with template engines and generators. (8 min read)

Generate fake data to be used in your applications based on a JSON schema document. (4 min read)

Use the ts-json-schema-generator package to generate a valid JSON schema from your TypeScript types. (3 min read)

Output DMBL files from your Prisma schema and see how you can view it online. (4 min read)

Create new Stripe subscription products from a simple TypeScript script. (3 min read)

Set yourself up for success in large Next.js project structures by following this opinionated layout. (12 min read)

I share 5 of the Figma plugins that sped up my workflow 10x. (3 min read)

Don't mind me, I am just testing my scheduled blog post workflow. (1 min read)

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

Automate the process of creating shortened URLs for your Next.js posts with this how-to guide. (6 min read)

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

See how to use Jest alongside GitHub Actions run Jest testing in CI. (5 min read)

See how easy it is to build a TypeScript NPM package using Parcel 2. (8 min read)

Avoid dirty reads on highly contended cache resources in Node.js with the Redlock package. (11 min read)

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

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. (15 min read)

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. (8 min read)

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

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. (4 min read)

In our final coverage of regression using SciKit Learn, we look at how we can use regression with regularization. (5 min read)

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

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. (5 min read)

This short recap on Kubernetes will set the foundation for the upcoming series on Kubernetes and EKS. (7 min read)

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

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

The 100 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. (10 min read)

Deploy a simple Python lambda function with the TypeScript AWS CDK to LocalStack. (7 min read)

Deploy a Kubernetes Fargate on EKS cluster using the AWS CDK. (4 min read)

Apply an oil paint effect to images in Python with OpenCV. (2 min read)

Learn how to use GitHub Actions to speed up your Pip package deployments to PyPi. (4 min read)

Use the ECS patterns library to deploy a simple Fargate cluster to LocalStack. (11 min read)

Learn how to generate random data and export it to CSV to use in your projects. (8 min read)

The second part of this demo will show how to interact with our DynamoDB table using DynamoDB Toolbox. (6 min read)

Use Conventional Commits, pre-commit and Commitizen to automate your versioning based on commit messages. (6 min read)

A walkthrough on how to deploy a local DynamoDB table to LocalStack with the AWS TypeScript CDK. (10 min read)

Learn how to deploy your first package to Pip in this straight-forward tutorial. (8 min read)

Use the TypeScript AWS CDK to deploy an S3 Bucket fronted by a CloudFront CDN and Route53 record. (13 min read)

Build off previous work on PyTest by adding a GitHub action to run PyTest in CI. (4 min read)

Explore PyDoc and understand how it can improve your documentation and how to search it. (7 min read)

Speed up your local AWS CDK development but using LocalStack and the AWS CDK Local wrapper package. (5 min read)

Get started with the AWS CDK in TypeScript and learn some of the foundational work for upcoming tutorials. (12 min read)

Explore how to work with the time module from the Python Standard Library in detail. (3 min read)

Learn how to set up reliable PyTest unit tests for the Python datetime library with FreezeGun. (5 min read)

Learn how to work with the datetime library in Python. (4 min read)

An overview look at custom exceptions in Python (4 min read)

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

See how the Rich library for Python can make it easy to add color and style to terminal output. (4 min read)

Introduce yourself to MoviePy through a simple example to add text to video. (4 min read)

Make debugging Python errors more enjoyable. (2 min read)

Use PyInquirer to create more interactive and user-friendly command line prompts. (5 min read)

Display your public GitHub repositories in an interactive notebook. (2 min read)

Using the OS module recursively make folders on your operating system. (1 min read)

Learn the basics of installing and using PyTest with a basic math module example. (4 min read)

Work through an example of building a simple CLI script with the python-fire library. (3 min read)

A method to protect your Next.js routes from being accessed in production. (5 min read)

A Sunday morning product built to help be more public about my work and day-to-day life. (1 min read)

Use the glob library to create a list of all the files in a directory. (3 min read)

Learn how to take a markdown file and parse the frontmatter metadata for usage in your scripts. (2 min read)

Use the Pillow image library to add text and icons layers to an image programmatically. (4 min read)

Installing and using an unofficial Python Unsplash API by salvoventura (3 min read)

Setting up a Jupyter Notebook for the first time to aid with the 100 Days of Python challenge (3 min read)

Slowly introducing yourself to the world of generative art with this short introduction (7 min read)

Use the Node debugger to visualise performance (5 min read)

See how you can get started with the VSCode debugger for Node.js applications (10 min read)

An easy-to-understand example of how to run automated jobs using crontab on your Mac (5 min read)

Learn how to setup LocalStack to help with local development emulating AWS products (4 min read)

Learn how to play around with DynamoDB locally and use NoSQL Workbench to plan out your work (4 min read)

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

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. (8 min read)

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

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

This blog post will explore the new Next.js Image component for an optimised image experience on the web. (4 min read)

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 (7 min read)

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 (10 min read)

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. (5 min read)

Learn how to deploy the base Next.js 10 app with the Vercel CLI and/or the Vercel GitHub Integration (4 min read)

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

Learn how to export static HTML from a Nextjs 10 project to host (3 min read)

Updating my previous post on using Create React App with Snowpack for the latest versions and NPM 7 (1 min read)

Using Webpack 5 to build lambdas for AWS deployments (5 min read)

A look into how you can run a cron job to self-destruct tweets (6 min read)

Generate strongly-typed models and serializers from JSON, JSON Schema (7 min read)

Using TypeScript to standardise types across the board using JSON Schema (4 min read)

Prevent Breaking API Changes With OpenAPI And openapi-diff (4 min read)

Validate Your APIs With OpenAPI Schema Validator, YML and JSON (4 min read)

Explore a tool kit of models that you can apply to your own work day (10 min read)

Look at how you can create your first ESLint rule and apply it to a working application (8 min read)

Look at how we can work around one of the Service Worker's biggest misunderstanding (4 min read)

A quick overview of adding/retrieving secrets for AWS (3 min read)

Tips and tricks for how you can become the developer you've always wanted to be (17 min read)

Extend the Error prototype with ES6 classes to capture errors and send them to Sentry (8 min read)

A quick look at building a heat map in D3 (5 min read)

Explore how redirection works in C (5 min read)

Use the React Context API with Tailwind's theme generator to access the values anywhere throughout the application (6 min read)

Get up and running with Tailwind faster than your bread takes to toast (4 min read)

Discover how the Skypack CDN can help use your favourite modules with Deno (2 min read)

Some learnings and reflections after hitting a month of sharing (8 min read)

Upgrade a CRA template to start making use of Snowpack (7 min read)

A look at named pipes and how we can interact with them in Golang (5 min read)

An evening project to speed up small, rough diagrams from the command line (12 min read)

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

Tired of Twitter negativity? Avoid it all by posting from the safety of the command line! (5 min read)

Run through the basics to get your first Docker GitHub Action up and running (6 min read)

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

This year has been... strange. (8 min read)

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. (9 min read)

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. (9 min read)

Learn the lessons that I had to find out the hard way when it came to learning languages over and over and over... (14 min read)

A short example of setting up your first npm GitHub package (3 min read)

An entry-level look at how to setup determinstic Python environments using Pipenv (6 min read)

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. (9 min read)

A short morning run over setting up the factory_bot_rails gem with RSpec (4 min read)

In this example, we will screenshot vaild HTML with Puppeteer (10 min read)

Follow along as we do the bare minimum to start generating files using EJS from the command line (10 min read)

Improve your Design System with these websites that work as together as a foundation into your next UI iteration (4 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (3 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (2 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (3 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (3 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (4 min read)

Follow along in this short Stripe series as we take a look at making a Stripe charge in a few different languages! (3 min read)

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 (11 min read)

Satirical Tech Lead Fridays (5 min read)

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

How I built a local Alfred extension to quickly jump to the web page online (3 min read)

Using the Babel AST Parser to help find unused JS/TS/Less/SCSS files in the code base (7 min read)

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 (6 min read)

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. (7 min read)

Use Nodejs and Xray to scrape the blog website (3 min read)

Use tmuxinator to setup projects that require complex setups (3 min read)

Use Node.js and Octokit to programatically create a markdown file in a GitHub repo (3 min read)

A short look at some important algebra properties and their formulas (3 min read)

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 (9 min read)

Challenges and process to get the blog converted over to Gatsby + Netlify CMS (5 min read)

An overview of network addressing and how to understand concepts like network masking. (4 min read)

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

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

A short look at the data types available when using Scala. (2 min read)

Looking at usage of the web "fetch" API. This example uses the node-fetch library for demonstration purposes. (2 min read)

Looking at usage of the web "fetch" API. This example uses the node-fetch library for demonstration purposes. (3 min read)

A short look at how to sum an integer list and manipulate a string list using Java 8 streams. (2 min read)

A look into the common terms and their definitions when using Apache Kafka. (6 min read)

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

A small intro into how you can get started with Cassandra using Docker and basic syntax. (4 min read)

A quick look at how RxJS implements an autocomplete subscription. (2 min read)

A quick overview of a number of programming paradigms and what are some key defining features. (2 min read)

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

Looking at how we can normalise data using the d3-scale library. (10 min read)

The tl;dr reminder of how Reselect works for Redux state memoization. (1 min read)

tl;dr Syd => Melb. (1 min read)

Go implementation of a Binary Search Tree. (3 min read)

A deeper look into processes under the hood. (8 min read)

Creating a D3 word cloud from a base Create React App project. (4 min read)

Creating queues to schedule workers using Kue.js, Node.js and Redis (2 min read)

An introduction to what EKS is. (4 min read)

Adding Redux Persist to React Native for data persistence. (1 min read)

Python implementation of comparing two strings to check if they are anagrams. (1 min read)

An introduction into managing packages on Kubernetes with Helm. (7 min read)

A look into how threads operate. (6 min read)

A short look into B-Tree structures, what defines them and some technologies that use them. (2 min read)

A basic look at how to add Istio to your EKS cluster. (6 min read)

An introduction to React Hooks. (2 min read)

The classic FizzBuzz implementation in Rust with Unit Testing. (2 min read)

Ruby implementation of a basic node tree and traversal using DFS and BFS. (2 min read)

How to setup Detox to run e2e tests for an Expo application. (2 min read)

PHP implementation of a Binary Search Tree. (2 min read)

Golang implementation of a basic node tree and traversal using DFS and BFS. (3 min read)

Java implementation of a basic unidirectional Linked List. (5 min read)

Ruby implementation of a Binary Search Tree. (2 min read)

JavaScript implementation of comparing two strings to check if they are anagrams. (1 min read)

Go implementation of a basic unidirectional Linked List. (6 min read)

Python implementation of a Binary Search Tree. (2 min read)

JavaScript Spiral Matrices with unit testing. (2 min read)

Setting up a MySQL container for local development. (1 min read)

Basic usage and command calls for Redis from the command line. (2 min read)

Python implementation of a basic node tree and traversal using DFS and BFS. (2 min read)

A basic intro to using the Redis chart and installing it with Helm. (1 min read)

Adding credentials to be used for EKS when pulling images from Docker Hub. (1 min read)

Basic intro to anonymous functions with PHP. (1 min read)

Basic instructions on how to use EKSCTL on the command line. (4 min read)

Basic applications of slices. (2 min read)

How to build instances with Ruby. (2 min read)

Basic error handling with exceptions in Python. (1 min read)

Building instances with PHP classes. (1 min read)

Java Spiral Matrices with unit testing. (2 min read)

Basic unit testing for PHP. (1 min read)

How to create basic lambda functions in Java requiring interfaces. (1 min read)

Linking two Docker containers to run a Nodejs app behind a NGINX reverse proxy. (2 min read)

A quick look at Ruby Lambda and Proc functions. (1 min read)

Basic string manipulation in Golang using the strings package. (2 min read)

Basic push, pop, shift and unshift applications for PHP. (2 min read)

PHP implementation of a basic unidirectional Linked List. (1 min read)

Basic implementation of maps in Java. (1 min read)

Using the arrays and array list utility packages in Java. (2 min read)

See what I do when it comes to JavaScript logging for web. (3 min read)

Create a basic payment with Braintree using React and Nodejs! (7 min read)

Simple basics on a GET and POST request for Gin in Go. (2 min read)

An introduction to React Portals. (1 min read)

Checkout how to create dynamic diagrams using mermaid! (5 min read)

Golang Spiral Matrices with unit testing. (2 min read)

Examples on how to handle errors in Ruby. (1 min read)

Example of adding in Amplify (1 min read)

Short introduction and link to the MyRocks engine. (1 min read)

Solution in Java. (1 min read)

Solution in Java (2 min read)

Suggestions and guides for naming in JavaScript. (1 min read)

Resources for log-structured merge trees. (1 min read)

A look at current base principles. (6 min read)

A small intro into auto-determining WCAG color contrast standards (1 min read)

What do you do when your content becomes super long? (1 min read)

Say hello to an easy way to parse CLI args and options with yargs parser. (3 min read)

Ruby implementation of a basic unidirectional Linked List. (2 min read)

Use the incredible Sharp package for Node and build a simple CLI image compression tool. (7 min read)

The classic FizzBuzz implementation in Golang with Unit Testing. (2 min read)

See example code on how to debounce trailing and leading events. (3 min read)

An introduction to React Context. (3 min read)

See example code for dynamically importing a React Component. (1 min read)

Python Spiral Matrices with unit testing. (2 min read)

PHP implementation of a basic node tree and traversal using DFS and BFS. (2 min read)

Python implementation of a basic unidirectional Linked List. (4 min read)

Ruby implementation of comparing two strings to check if they are anagrams. (1 min read)

PHP implementation of comparing two strings to check if they are anagrams. (1 min read)

An example of a simple health check for Kubernetes. (1 min read)

The classic FizzBuzz implementation in Ruby with Unit Testing. (1 min read)

PHP Spiral Matrices with unit testing. (1 min read)

The classic FizzBuzz implementation in Python with Unit Testing. (1 min read)

Ruby Spiral Matrices with unit testing. (2 min read)

How to use the Expo API to log into Facebook and authenticate on AWS Amplify. (1 min read)

The classic FizzBuzz implementation in Java with Unit Testing. (1 min read)

The classic FizzBuzz implementation in JavaScript with Unit Testing. (1 min read)

The classic FizzBuzz implementation in PHP with Unit Testing. (1 min read)

Blog initiation and hazing. Read my primary objectives with this blog and the series I will write about. (2 min read)