TutorialEdge.net

Part 1 - Project Setup and Your First Window

Fri, 29 May 2026 10:01:00 +0000

Welcome to the first part of this series on graphics programming with wgpu in Rust! By the end of this article, you’ll have a Rust program that opens a window and responds to input events. It doesn’t draw anything yet, but it’s the skeleton that everything else will hang from.

What is wgpu?

wgpu is a Rust graphics library that talks to your GPU using whichever native API your platform provides — Vulkan on Linux, Metal on macOS, DirectX 12 on Windows, and WebGPU in the browser. You write one codebase and it runs everywhere.

Part 1 - Project Setup & Your First HTTP Proxy

Fri, 20 Mar 2026 10:01:00 +0000

Welcome to the first part of this series on building an API gateway in Rust! By the end of this tutorial, you’ll have a working reverse proxy that accepts incoming HTTP requests and forwards them to a backend server. It’s a surprisingly small amount of code, and it’ll give us a solid foundation to build on.

What is a Reverse Proxy?

Before we write any code, let’s make sure we’re on the same page about what a reverse proxy actually does.

Security in Go - Building a Port Scanner in Go

Sat, 15 Feb 2020 15:06:51 +0000

Welcome to the first tutorial in this new series on building security tools in Go! In this tutorial, we are going to be building a very cool port scanner which you will be able to point at a server and probe for any potential vulnerabilities.

This will give us a good understanding of what Port Scanning is and why we should be aware of what ports we are leaving open on any of the machines that we run our applications on top of.

Part 1 - Project Setup

Mon, 23 Dec 2019 18:44:50 +0100

In the first part of this tutorial series, we are going to be working on project setup for both the frontend and the backend of the Imgur image-hosting clone that we are going to be building.

By the end of this section, you will have two separate projects that built using the vue cli for our frontend Vue.js application and the npm cli for our backend Node.js REST API that will be powering our frontend.

Challenge 01 - Type Assertions in Go

Sun, 24 Nov 2019 11:05:52 +0000

In this challenge, we are going to become familiar with the concept of Type Assertions in Go!

Preface

If you are new to the language, then type assertions are a concept that can sometimes trip you up and appear a little tricky at first, but after overcoming the syntax it becomes far easier to understand.

Through using type assertions, we can retrieve the dynamic value of an interface. For example:

Getting Started With Go

Sat, 22 Sep 2018 15:23:16 +0100

Go is an absolutely incredible language for building a wide variety of different applications. From command-line interfaces to distributed microsystems and even cloud platforms, its simplicity and concurrency baked in make it a powerful choice of language for many development teams.

In this tutorial, I will be embarking on a mission to help get you up and running with the language so that you can go off and build ever-more brilliant applications and help push forward technology.

Designing the EveryNote Web App with Vue.js and Vuex

Fri, 27 Jul 2018 19:36:57 +0100

In this article, you’ll learn to develop an application to take notes, called EveryNote, from scratch. You’ll analyze and design the application, as well as preparing the folder structure for the project. After that, you’ll build the application incrementally through tests and code, providing a real-world Vuex development example.

The application can be downloaded by cloning the https://github.com/PacktPublishing/-Vuex-Condensed Git repository. You’ll require Node.js installed on a system. Finally, to use the Git repository, the user needs to install Git. The code files of this article can be found on GitHub: https://github.com/PacktPublishing/Vuex-Quick-Start-Guide/tree/master/chapter-4.

Form Validation With Vuelidate in Vue.js

Thu, 07 Jun 2018 19:36:57 +0100

Learn how to validate forms using Vuelidate in this tutorial by Paul Halliday, the author of Vue.js 2 Design Patterns and Best Practices.

In this post, you’ll use a third-party library named Vuelidate to perform model validation depending on a particular rule set

Create a New Vue Project

Create a playground project by running the following in your Terminal:

## Create a new Vue project
$ vue init webpack-simple vue-validation

## Navigate to directory
$ cd vue-validation

## Install dependencies
$ npm install

## Install Vuelidate
$ npm install vuelidate

## Run application
$ npm run dev

What is Vuelidate?

Vuelidate is an open source, lightweight library that helps you perform model validation with a variety of validation contexts. Validation can be functionally composed and it also works well with other libraries such as Moment, Vuex, and more. As you’ve installed it in your project with npm install vuelidate, you now need to register it as a plugin within main.js:

Managing State With Vuex in Vue.js

Sat, 31 Mar 2018 19:06:13 +0100

State management is something you will ultimately have to deal with as you create increasingly complex frontend applications. Thankfully, with the help of Vuex, this isn’t as hard as you may think!

Installation

In order to install vuex, you will have to use either yarn or npm like so:

## Npm
$ npm install vuex
## Yarn
$ yarn add vuex

Setting up Vuex

Once you have successfully installed Vuex in your VueJS application, you can set your application to use it by doing the following within your main.js file:

Part 1 - Setting Up Our CI/CD Pipeline to S3

Mon, 19 Mar 2018 16:24:13 +0000

If you know anything about me, you’ll know I am incredibly lazy. This means that it’s incredibly important to set up an automated deployment pipeline early in the project’s development.

If we are serious about developing a decent website that will make us tonnes of money then we need to get this working from the start. Afterall, if it takes us about 5-10 minutes to deploy our site, by automating this we’ll be saving ourselves 5-10 minutes every time we wish to push up changes.

Part 1 - Initial Setup

Mon, 19 Mar 2018 11:05:52 +0000

We’ll start off this course by setting up both of our projects. Once we’ve got the fairly boring setup out of the way, we can begin to add new functionality and build up our application and see some positive results!

Goals

By the end of this part of the tutorial series, you will have:

Created the basic Go application within a backend/ directory.
Created a basic ReactJS application within a frontend/ directory.

With both of these achieved, you will then be able to start adding functionality to your real-time chat system in the following parts of the course.

Getting Started With Vue.js

Wed, 28 Feb 2018 20:27:49 +0000

In this tutorial, we are going to look at how you can setup your development environment so that you can get started writing your own VueJS.

We will be utilizing the vue-cli in order to start our project off and then we’ll be diving in and making a few edits, before finally building it using the same vue-cli.

Video Tutorial

A Simple Vue App

Before I get started, it must be noted that you can get up and running really quickly with VueJS 2 in less than 30 lines of code. Below you will find a webpage that is a very simple VueJS page that simply prints out Hello World to the browser when hit.

Getting Started With Python

Mon, 18 Sep 2017 19:47:29 +0100

This tutorial uses Python version 3.6

Introduction

In this course we’ll be taking a look at the absolute basics of the Python programming language and cover everything you need to get up and running creating your own basic Python programs.

The full text version of this course can be found by clicking on the Python Programming Course card on the homepage of my site.

Installing Python

Let’s dive in. So before we can get started working with the Python programming language you’ll first need to install the latest version of Python onto your local development machine. For the purpose of this video series we shall be using version 3.6.2.

An Introduction To Web Development

Sun, 16 Apr 2017 17:27:53 +0100

Since it’s inception in the 90s the web has seen an explosion in the number and range of different web technologies used for building websites. However, if you have never created a website in your life then this can all be very daunting and initially offputting for someone wanting to take the plunge and get into web development seriously. In this introductory guide I’ll be helping to demystify some of the key terms and concepts that every web developer should know or be aware of.

Part 2 - The Render Pipeline

Fri, 29 May 2026 10:02:00 +0000

In Part 1 we opened a window. In this part, we connect that window to the GPU and draw our first frame — a solid colour fill. It’s a modest result, but it means the full rendering pipeline is working end-to-end.

How the GPU Pipeline Works

Before writing code, here’s the mental model you need.

CPU side: recording commands

The CPU never tells the GPU to draw a single pixel directly. Instead it records a list of operations into a command encoder — think of it as building a script to hand off. That script captures one or more render passes, each of which describes what to draw and where to write the results.

Part 2 - Routing & Path Matching

Fri, 20 Mar 2026 10:02:00 +0000

In the previous tutorial, we built a basic reverse proxy that forwards all requests to a single backend server. That’s a good start, but a real API gateway needs to route requests to different services based on the URL path.

For example, requests to /api/users might go to a user service on port 8081, while requests to /api/orders go to an order service on port 8082. This is the bread and butter of what an API gateway does.

Defining the Comment Service

Sat, 13 Feb 2021 12:00:00 +0100

Now that we have our database setup, we have everything we need to start implementing our comment service and build it in a test-driven way.

We’ll start off by defining the interface for our comment service:

package comment

import (
	"time"

	"github.com/jinzhu/gorm"
)

// Service - our comment service
type Service struct {
	DB *gorm.DB
}

// CommentService -
type CommentService interface {
}

// NewService - returns a new comments service
func NewService(db *gorm.DB) *Service {
	return &Service{
		DB: db,
	}
}

Next, we’ll need to define the methods that we want to be part of this service and we’ll also need to define the struct for our Comment object:

Handling JSON

Sat, 13 Feb 2021 12:00:00 +0100

Now, at present we don’t currently handle JSON and we don’t return JSON from our API, so it’s not exactly what you would call a JSON REST API just yet. So, in this video, we are going to look at how you can effectively work with JSON and encode and decode JSON within the transport package.

Implementation

So, let’s open up the handler.go file within the transport package. The first thing we are going to improve is the API health check endpoint and instead of returning a simple string, we are instead going to change this to return a JSON response.

Implementing Our Repository Layer

Sat, 13 Feb 2021 12:00:00 +0100

Now that our Postgres DB is up and running, we now have to implement the package that we’ll use to communicate to this database.

Create a new directory within your internal directory called database. Within that create a new file called database.go:

package database

import (
	"fmt"
	"os"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/postgres"
)

// NewDatabase - returns a pointer to a new database connection
func NewDatabase() (*gorm.DB, error) {
	return nil, nil
}

Now, within the NewDatabase function, we’ll want to setup a connection and then ping that connection to ensure it’s working as intended.

Implementing The Comment REST API Endpoints

Sat, 13 Feb 2021 12:00:00 +0100

In this video, we’ll be defining the HTTP endpoints that are effectively going to expose the our comment service.

Implementing the Comment Service

Sat, 13 Feb 2021 12:00:00 +0100

So now that we’ve defined our comment service interface, let’s set about actually implementing the methods that we’ve defined.

Getting a Comment By ID

So let’s start off by defining the GetComment method.

// GetComment - retrieves comments by their ID from the database
func (s *Service) GetComment(ID uint) (Comment, error) {
	var comment Comment
	if result := s.DB.First(&comment, ID); result.Error != nil {
		return Comment{}, result.Error
	}
	return comment, nil
}

So GetComment retrieves comments by their ID from the database. We’re going to pass in the ID here and then say, if the result.Error is not nil, then return an empty comment struct. Otherwise, we want to return the comment and a nil error.

Running Postgres Locally with Docker

Sat, 13 Feb 2021 12:00:00 +0100

In the previous video in this course, we looked at how we could implement the transport package. Now, we are going to take a step back and look at how we can implement the storage layer of this service.

We need some form of storage system to store all of the comments from our incredible users. Since we know what the structure of our comments will look like, a SQL database is ideal for our situation. As such, we’ll be using Postgres to store everything.

Implementing the Transport Package

Sat, 06 Feb 2021 12:00:00 +0100

So, we have our basic app structure defined, let’s start looking at how we can build out the server aspect and start serving some basic endpoints.

Now that we have some idea as to how we can structure our app, it’s time to dive in and start fleshing out some of the basic functionality.

The first endpoint we’ll want to build is a simple health check endpoint that simply returns a status 200 OK if the service is up and healthy. Health checks are important in applications and, if done correctly can quickly return the operational health of your systems and alert you when things go bad.

Connecting to RabbitMQ in Go

Sun, 06 Dec 2020 12:00:00 +0100

Now that we have our RabbitMQ instance up and running, it’s time to start developing applications on top of it.

Consuming Messages from RabbitMQ

Sun, 06 Dec 2020 12:00:00 +0100

So, we’ve accomplished quite a lot so far, we’ve managed to set up a well structured app that is able to create a queue and subsequently publish messages to this queue.

In this video, we are going to be focused on how we can do the reverse and consume the messages that we have published to this queue.

Creating Queues and Publishing Messages

Sun, 06 Dec 2020 12:00:00 +0100

Let’s expand on our RabbitMQ service and add the ability to create queues and publish some messages to these newly created queues.

RabbitMQ Crash Course For Go - Course Overview

Sun, 06 Dec 2020 12:00:00 +0100

Welcome Gophers! In this course, we are going to be covering everything you need to know in order to quickly get started developing Go applications on top of RabbitMQ.

Setting up RabbitMQ locally using Docker

Sun, 06 Dec 2020 12:00:00 +0100

We’ll start off our journey setting up a locally running instance of RabbitMQ that we can connect to and base our learnings off for now.

In order to run this instance we’ll be using docker as it affords us a number of advantages such as the ability to quickly teardown and spin up a fresh RabbitMQ instance should we mess anything up or want to start from scratch!

So, first things first, you will need to ensure you have docker for desktop installed on your machine so that you can startup and run docker containers. Once you have this installed and available on your path open up a terminal and run the following:

Rust Module Tutorial

Sun, 05 Apr 2020 08:53:05 +0100

Welcome Rustaceans! In this tutorial, we are going to take a look at Modules in Rust and how you can define your own simple modules.

By the end of this tutorial, we will have covered:

The absolute basics of modules in Rust
The rules around defining your own modules

With this in mind, let’s dive in!

Modules in Rust

When you first start learning Rust coming from another programming language, one of the first problems you typically come up against is - “How do I split my code into multiple files?”.

Part 2 - Creating Simple Vue.js Components

Sat, 28 Dec 2019 18:44:50 +0100

In the previous part of this project series, we scaffolded the basic structure of both the frontend and the backend of our project. Once we were happy that everything was setup correctly, we then created a github repository in which our project now lives.

With the setup out of the way, we can now start to dive down into developing the frontend and learnings some of the critical, core Vue.js concepts that you’ll need in order to succeed as a Vue.js developer.

Challenge 02 - Satisfying Interfaces in Go

Sun, 24 Nov 2019 11:05:52 +0000

In this challenge, you are going to implement the necessary methods needed to satisfy the provided Go interface.

On the left hand screen, you have a simple Go application that features an interface called Employee.

In order to complete this challenge, you will have to complete the code and satisfy this interface.

View Solution

package main

type Employee interface {
 Language() string
 Age() int
}

type Engineer struct {
 Name string
}

func (e Engineer) Age() int {
 return 26
}

func (e Engineer) Language() string {
 return e.Name + " programs in Go"
}

func main() {
 // This will throw an error
 var programmers []Employee
 elliot := Engineer{Name: "Elliot"}
 // Engineer does not implement the Employee interface
 // you'll need to implement Age() and Random()
 programmers = append(programmers, elliot)
}

Using RwLock and CondVars in Rust

Sat, 01 Sep 2018 15:09:49 +0100

Read many, write exclusive locks – RwLock

Consider a situation where you have a resource that must be manipulated only a single thread at a time, but is safe to be queried by many—that is, you have many readers and only one writer.

While you could protect this resource with a mutex, the trouble is that the mutex makes no distinction between its lockers; every thread will be forced to wait, no matter what their intentions. RwLock<T> is an alternative to the mutex concept, allowing for two kinds of locks—read and write. Analogously to Rust’s references, there can only be one write lock taken at a time but multiple reader locks, exclusive of a write lock. Here’s an example:

Learning Generics in Rust

Sat, 01 Sep 2018 14:52:49 +0100

Generics are a facility to write code for multiple contexts with different types, and parameterization allows the programmer to write code that makes fewer assumptions about the data structures and code segments involved in the code’s definition.

For example, a very ambiguous concept would be the concept of addition. When a programmer writes a + b, what does that mean? In Rust, the Add trait can be implemented for just about any type. As long as there is an implementation for the Add trait in scope that is compatible with the types of a and b, this trait will define the operation.

Go Basic Types Tutorial

Sat, 14 Jul 2018 22:24:26 +0100

In this tutorial, we are going to be looking at all of the basic data types available to us within the Go language. By the end of this tutorial, you should be comfortable with the various different types available within the language and hopefully some understanding as to how you can use these within your own Go programs.

This kind of material can be fairly dry and boring to learn so I’ll try and spice things up and make it somewhat interesting whilst also covering the necessary basics.

Part 2 - Getting Started With AWS Lambda

Thu, 19 Apr 2018 21:42:29 +0100

So, in the last tutorial, we managed to get a simple CI/CD pipeline up and running so that whenever we commit anything to our github repo, it automatically builds and deploys these changes to our “production” environment.

In this tutorial, we are going to continue to develop our blog and get started building up the first of our Lambda functions that we’ll need to make our blog work.

Our First Lambda Function

We’ll start by creating a hello world style lambda function that will later return a paginated list of blog posts. Once we’ve managed to successfully deploy this version 1 of the endpoint, we can then start working on integrating it with our DynamoDB table that we’ll be creating later on in the series.

Part 2 - Simple Communication

Mon, 19 Mar 2018 11:05:52 +0000

Note - This post is part 2 of a series on building a chat application in Go with ReactJS. You can find part 1 here - Part 1 - Initial Setup

So, now that we have our basic frontend and backend set up, it’s time to actually do something with them.

In this part of the series, we’ll be implementing a basic WebSocket server which will listen for messages and write them back to via the same WebSocket.

Vue.js Components Tutorial

Thu, 01 Mar 2018 12:26:40 +0000

This Tutorial builds off the starter application that we generated in the Getting Started with VueJS article.

Video Tutorial

This tutorial is also available in video format if you wish to watch it!

Introduction

In this tutorial, we are going to look at how you can work with components within your VueJS applications. We are going to start at looking at very simple components and then move on to your standard .vue file components.

Functions and Variables in Python

Mon, 18 Sep 2017 19:19:39 +0100

Variables in Python

Let’s first have a look at variables. A variable is essentially a place where we can store the value of something for processing later on. Imagine you wanted to write a program that doubled a number for us, not the most exciting of programs I know but it is a good example.

We would first want to define a variable to store our number, double it and then print it out.

Part 3 - Drawing Your First Triangle

Fri, 29 May 2026 10:03:00 +0000

The triangle is the “hello world” of graphics programming. In this part we define vertex data, upload it to the GPU, write our first shaders in WGSL, and draw a colourful triangle to the screen.

Add bytemuck to Cargo.toml before you start:

Cargo.toml

[dependencies]
wgpu = "29.0.3"
winit = "0.29.1"
pollster = "0.4.0"
env_logger = "0.11"
log = "0.4"
bytemuck = { version = "1.14", features = ["derive"] }

What is a Vertex Buffer?

The GPU doesn’t know about Rust structs. To draw geometry, you copy raw bytes into a vertex buffer — a block of GPU memory that the vertex shader reads one vertex at a time. We define a Vertex struct, fill a slice of them, and upload it.

Part 3 - Middleware Pipeline

Fri, 20 Mar 2026 10:03:00 +0000

In the previous tutorial, we added routing to our gateway. Now it’s time to add middleware — the mechanism that lets us process requests and responses as they flow through the gateway.

Middleware is where the real power of an API gateway lives. Logging, authentication, rate limiting, header manipulation — these are all concerns that apply across services, and middleware lets us handle them in one place rather than duplicating logic in every backend service.

Part 3 - Adding The Vue Router to our Application

Thu, 02 Jan 2020 18:44:50 +0100

In the last tutorial in this series, we looked at building a really simple component within our Imgur application. Now that we have some fo the basics under our belt when it comes to building components, it’s time to look at how we can start building a more complex application and introduce multiple components and a router that allows us to switch between rendering certain components.

Introduction

In this tutorial, we’ll be looking primarily at how you can set up your Vue.JS application to use the incredibly popular vue router package. We’ll be covering how routing works in terms of all Single Page Applications, and then how it specifically works within Vue.JS.

Challenge 03 - Sorting Flights by Price

Sun, 24 Nov 2019 11:05:52 +0000

In this challenge, you are going to be attempting to sort a list of Flights based on their price from highest to lowest.

You will have to implement the SortByPrice function that takes in a slice of type Flight and returns the sorted list of Flights.

In order to help you see what is going on, you have been provided a very quick printFlights function which you can use to print the flights out.

Part 3 - Setting Up our RDS Database

Tue, 24 Jul 2018 21:19:40 +0100

Introduction

Welcome back to part 3 of my course on building a blog with Vue.JS on AWS. In this part of the course, we are going to be setting up an RDS instance which will store all of our blog’s articles and posts.

Once we have our database instance set up and our schema defined, we can then move on to building Lambda functions that will query this database and return the results to our frontend.

Go Composite Types Tutorial

Sat, 14 Jul 2018 22:24:26 +0100

Welcome All! In this tutorial, we are going to be looking at the various different composite data types that are available in the Go programming language.

If you haven’t already, I’d suggest you check out my other tutorial in this course on Basic Data Types. You’ll need to know about these basic data types in order to understand some of the composite data types.

Arrays

Let’s dive into our first Composite data type, the array and see how we can declare arrays and work with them.

Part 4 - Setting Up Our Dynamodb Table

Fri, 20 Apr 2018 12:31:40 +0100

In the previous tutorial, we managed to get our first Lambda tutorial up and running, however, it doesn’t do anything too exciting as it stands. This is where Dynamo comes in, we need to create a DynamoDB table where we can store everything we need for our blog. This includes new blog posts, any comments, ratings, and whatever else we can think of!

Once we have this new table all defined, we can start to play about with inserting things and then retrieving them using our existing Lambda function. Let’s get started!

Part 3 - Designing our Frontend

Mon, 19 Mar 2018 11:05:52 +0000

Note - This post is part 3 of a series on building a chat application in Go with ReactJS. You can find part 2 here - Part 2 - Simple Communication

In this part of the series, we’re going to be looking at improving our frontend and fleshing out the application so that it looks and feels like a decent online chat application.

By the end of this part of the series, you should have a really solid looking frontend which looks a little something like this:

Vue.js Event Handling Tutorial

Sun, 04 Mar 2018 15:03:41 +0000

The official documentation for VueJS event handling can be found here: VueJS Event Handling.

In this tutorial, we are going to look at how you can successfully handle events within your VueJS applications. This is by no means a replacement for the official documentation, think of it more so as a suplementary guide filled with live examples!

Working with Lists in Python - Tutorial

Wed, 20 Dec 2017 19:22:48 +0000

This tutorial was built in Python 3.6

A Simple List

my_list = [1, 2, 3, 4] 
print(my_list)

Reversing a List

This quick and easy technique shows how you can access all the elements of a list in reverse order.

>>> my_list = [1,2,3,4,5]
>>> my_list[::-1]
[5, 4, 3, 2, 1]

Try it Out

my_list = [1, 2, 3, 4] 
print(my_list[::-1])

We can then treat our reversed list as an iterator and iterate through every element within this reversed list like so:

>>> for el in my_list[::-1]:
... print(el)
...
5
4
3
2
1

Conclusion

If you found this tutorial useful or require further assistance then please let me know in the comments section below or by tweeting me: @Elliot_F.

Part 4 - Colors and Uniforms

Fri, 29 May 2026 10:04:00 +0000

So far our triangle is static. In this part we add a CPU-to-GPU data channel called a uniform buffer, and use it to animate the triangle’s colour tint every frame.

What is a Uniform Buffer?

A uniform is a value that stays constant across all vertices and fragments in a single draw call, but can be updated between frames. It’s how you pass per-frame data — time, camera position, colour — from your Rust code into the shader.

Part 4 - Rate Limiting

Fri, 20 Mar 2026 10:04:00 +0000

In the previous tutorial, we built a middleware pipeline with logging, CORS, and header injection. Now we’re going to add one of the most important features of any API gateway: rate limiting.

Without rate limiting, a single client can overwhelm your backend services — whether intentionally (a DDoS attack) or accidentally (a buggy client in a retry loop). Rate limiting puts a cap on how many requests a client can make in a given time window.

Challenge 04 - Checking for Duplicates

Sun, 24 May 2020 21:23:23 +0100

In this challenge, we are going to be looking at how you can effectively filter out the duplicate entries from a slice in Go.

The task will be to implement the FilterDuplicates function so that it returns a slice of type string which contains only the unique names of developers retrieved from the inputted list.

Example:

// input
[]Developers{
 Developer{Name: "Elliot"},
 Developer{Name: "Alan"},
 Developer{Name: "Jennifer"},
 Developer{Name: "Graham"},
 Developer{Name: "Paul"},
 Developer{Name: "Alan"},
}

// output
[]string{
 "Elliot",
 "Alan",
 "Jennifer",
 "Graham",
 "Paul",
}

Hints

You may wish to use a map in your function in order to check if elements have already been seen by our function.

Go Functions Tutorial

Sat, 14 Jul 2018 22:23:10 +0100

In this tutorial, we are going to be looking at functions in Golang and hopefully, by the end of this tutorial, you will have a firm grasp as to what they are and how you can use them in your own projects.

We’ll be covering the following topics within this tutorial:

The basics on Function Declaration
Working with multiple return values

At the end of this tutorial, there will be challenges that you can attempt to complete on your own working machine that will help to validate what we have covered and give you a taste of writing your own functions in Go.

Part 5 - Getting Started With AWS Cognito

Fri, 20 Apr 2018 12:41:31 +0100

In the previous tutorial, we managed to get our DynamoDB table set up and populated with a couple of very simple posts. In this tutorial, we are going to set up a Cognito pool that will store all of the users that register for our Blog. We’ll also be able to improve our Lambda endpoints so that they aren’t open to the world, they require authentication before they start updating our database, this will stop unauthorized people potentially updating posts and doing malicious things.

Part 4 - Handling Multiple Clients

Mon, 19 Mar 2018 11:05:52 +0000

Note - This post is part 4 of a series on building a chat application in Go with ReactJS. You can find part 3 here - Part 3 - Designing Our Frontend

It’s time to implement the ability to handle multiple clients and broadcast any received messages to every connected client. By the end of this part of the series we’ll have:

implemented a Pool mechanism that will effectively allow us to track how many connections we have into our WebSocket server.
We’ll also be able to broadcast any received messages to all connections within our connection pool.
We’ll also be able to inform any existing clients when another client connects or disconnects.

Our application will look a little like this by the end of this part of the course:

Vue.js HTTP Requests with Axios Tutorial

Thu, 01 Mar 2018 12:36:54 +0000

This Tutorial builds off the starter application that we generated in the Getting Started with VueJS article.

In this article, we are going to look at how you can use the axios library to make HTTP requests within your VueJS 2 applications. The axios framework is without a doubt the most popular HTTP frameworks to use within the framework and makes the job of sending requests simple.

Working With The File System in Python

Wed, 20 Dec 2017 18:41:30 +0000

This tutorial was written using Python 3.6

Being able to work with the file system and do things like traverse directories or retrieve every file can be very handy in a number of different situations.

In this tutorial we’ll be taking a look at the various ways you can work with the file system in Python. Hopefully this will give you a decent grasp of some of the cool things you can do very quickly and succinctly using the Python programming language.

Part 5 - Textures and Image Loading

Fri, 29 May 2026 10:05:00 +0000

A triangle is a great proof-of-concept, but most real graphics involve images. In this part we load a PNG, upload it to the GPU as a texture, and sample it onto a textured quad.

Add the image crate to Cargo.toml:

Cargo.toml

[dependencies]
wgpu = "29.0.3"
winit = "0.29.1"
pollster = "0.4.0"
env_logger = "0.11"
log = "0.4"
bytemuck = { version = "1.14", features = ["derive"] }
image = "0.25"

Place any PNG image at assets/happy-tree.png in your project root. Any image will work — we’ll use it as the texture.

Part 5 - Load Balancing & Health Checks

Fri, 20 Mar 2026 10:05:00 +0000

In the previous tutorial, we added rate limiting to protect our backends from abuse. Now we’re going to tackle another critical piece of infrastructure: load balancing.

Up to this point, each route in our gateway maps to a single backend server. But in production, you typically run multiple instances of each service for reliability and throughput. If one instance crashes, the others keep serving traffic. Load balancing distributes requests across these instances.

Challenge 05 - Implementing a Stack in Go

Mon, 25 May 2020 19:47:24 +0100

👋 Welcome Gophers! In this challenge, we are going to be implementing some of the basic functionality of the Stack data structure in Go.

This is going to be the first of a number of data-structure questions which may come in handy if you are about to go in for an interview!

We’ll be carrying on the theme of flying from the previous challenge here and implementing 3 crucial methods needed to support a basic implementation of a stack.

Part 4 - Uploading and Storing Images

Sat, 04 Jan 2020 00:44:50 +0100

In this tutorial, we are going to look at building out the backend of our imgur clone and start creating a few simple AWS Lambda functions that will handle actions such as uploading and retrieving images.

This is where our application really starts to take shape and provide real value to our users, just without some critical functions like authentication and registration, which we will be covering in the next tutorial in this series.

Go Methods Tutorial

Sat, 14 Jul 2018 22:23:10 +0100

In this tutorial, we are going to first of all look at what methods are and how they work within the confines of the Go programming language. We’ll then take a look at demystifying the differences between both methods and functions and when you should ideally use them within your Go programs.

A Simple Example

Let’s start off by covering what methods and how we can implement our own in our Go systems. We’ll be creating an incredibly simple employee management system that allows you to Update an employees name and print that name out. Not the most exciting of example projects, but it’ll serve its purpose as a means of demonstration.

Part 5 - Improving the Frontend

Mon, 19 Mar 2018 11:05:52 +0000

Note - This post is part 5 of a series on building a chat application in Go with ReactJS. You can find part 4 here - Part 4 - Handling Multiple Clients

Welcome to the 5th part of this series! If you’ve made it this far then I sincerely hope you are enjoying learning new Go concepts and building up your own chat system in Go and React!

Vue.js Vue-Router Beginners Tutorial

Wed, 14 Mar 2018 19:12:49 +0000

The vue-router within VueJS allows you to create powerful Single Page Applications with minimal fuss. On a traditional website, each distinct page would constitute a request to the server to load the relevant file. So when someone navigated to http://myapp.com/page-1.html, the page-1.html file would be served up.

However, when navigating through a single page application, you only have see one request made to the server which returns your entire JavaScript application. This means you have full control over the experience your users have when navigating through your application, you can fully control any behaviours you wish in terms of transitions and this tends to give your site a far more dynamic look and feel.

Reading and Writing Files In Python

Sun, 10 Sep 2017 08:59:29 +0100

This tutorial was written using Python 3.6

Being able to effectively work with the filesystem in any programming language is important as there will always be a need to do things such as import data from files or store data in local files. In this tutorial we’ll be looking at how you can create files, write to these newly created and then subsequently delete these files once we are done.

Part 6 - 2D Transformations

Fri, 29 May 2026 10:06:00 +0000

Static images are a start, but real graphics need to move. In this part we apply a transformation matrix to the vertex shader so we can rotate and scale the textured quad every frame.

Add glam to Cargo.toml:

Cargo.toml

[dependencies]
wgpu = "29.0.3"
winit = "0.29.1"
pollster = "0.4.0"
env_logger = "0.11"
log = "0.4"
bytemuck = { version = "1.14", features = ["derive"] }
image = "0.25"
glam = { version = "0.27", features = ["bytemuck"] }

What is a Transformation Matrix?

A 4×4 transformation matrix encodes translation (position), rotation, and scale in a single structure. Multiplying a vertex position by the matrix produces the transformed position — all three operations in one GPU instruction.

Go Interfaces Tutorial

Thu, 28 May 2026 12:00:00 +0000

Source Code: The full source code for this tutorial is on GitHub: TutorialEdge/Go-Interfaces-Tutorial

By the end of this tutorial, you’ll understand:

What interfaces are and why Go uses them
How to define your own interfaces
How Go satisfies interfaces implicitly — no implements keyword needed

Basic Example

If you’re new to Go, you’ll see interface{} (or its modern alias any) frequently in code. A function that accepts interface{} will accept a value of any type.

Part 6 - Configuration & Authentication

Fri, 20 Mar 2026 10:06:00 +0000

Welcome to the final part of the series! In the previous tutorial, we added load balancing and health checks. Our gateway is fully functional, but everything is hardcoded in main.rs.

In this tutorial, we’ll make two final improvements: moving all configuration into a YAML file so you can change the gateway’s behavior without recompiling, and adding JWT authentication middleware so the gateway can protect backend services from unauthorized access.

Test Paid Video

Wed, 01 Jul 2020 21:12:04 +0100

In this tutorial, we are going to be implementing Auth0 into our React.js application. This will allow users to sign up and create a profile within our app.

🧙 Note - you can find the official documentation for setting up an Auth0 account here - Auth0 React Quickstart

Challenge 06 - Implementing a Queue in Go

Mon, 25 May 2020 19:47:24 +0100

👋 Welcome Gophers! In this challenge, we are going to be implementing some of the basic functionality of the Queue data structure in Go.

This is going to be the first of a number of data-structure questions which may come in handy if you are about to go in for an interview!

We’ll be carrying on the theme of flying from the previous challenge here and implementing 3 crucial methods needed to support a basic implementation of a Queue.

Part 5 - Authentication With Cognito and Route Guards

Sat, 11 Jan 2020 11:00:00 +0100

In this tutorial, we are going to be taking a first look at how we will be adding authentication/authorization to our Vue.JS Imgur application. This is a fairly large and complex topic, but we’ll be breaking it down into 2 parts.

In this part, we’ll be creating a helper class that will feature everything we need in order to talk to a cognito user pool that we’ll be creating again with terraform, and we’ll also be adding a few route guards to our application to see how these will protect certain sections of our app from unauthorized users!

Part 6 - Dockerizing your Backend

Mon, 19 Mar 2018 11:05:52 +0000

Note - This post is part 6 of a series on building a chat application in Go with ReactJS. You can find part 5 here - Part 5 - Improving the Frontend

In this part of the series, we are going to be focusing on adding Docker to our backend application.

Why are we doing this now you might ask? Well, before we look into things like authentication, load balancing and deployment, it’ll be good to have a standard way of deploying our application using containerization technology.

Vue.js Animations and Transitions Tutorial

Thu, 01 Mar 2018 12:26:40 +0000

In this tutorial, we are going to explore how we can use animations and transitions to make our VueJS web application really stand out from the crowd.

A Simple Transition

Let’s start of by creating a few very simple transitions, these will simply fade in when a certain condition is met. I was watching Mission Impossible whilst writing this so the theme for this is a top secret mission. The finished product for this section is going to look something like this:

Python Maps Tutorial

Wed, 24 May 2017 07:57:51 +0100

This tutorial was built using Python 3.6

Maps in Python are syntactic sugar that allow you to very succinctly iterate through every element of an array and perform a function on it.

Imagine we started off with a list of values numbering from 2-6 like so:

values = [2,3,4,5,6]

And we had a function which doubled said values:

def double(x):
 return x * 2

Without the use of maps we would have to do something like so in order to multiply every element:

Part 6 - Our Login/Registration Flow

Tue, 14 Jan 2020 12:00:50 +0100

In the previous tutorial in this series, we looked at creating a Cognito User Pool using Terraform and creating the cognitoAuth class which we then hooked up to some route guards in order to protect some special areas of our application.

In this tutorial, we are going to be extending this and building out our register/login flow so that new people coming into the application can register a new account and login/logout as and when they wish.

Challenge 07 - Minimums, Maximums and Errors

Sun, 24 Nov 2019 11:05:52 +0000

👋 Welcome Gophers! In this challenge, we’ll be testing your ability to handle edge cases and work with the errors package.

In this challenge, you have the task of implementing the GetMinMax function which will take in a slice of type Flight.

The function will return 3 values:

min - The cheapest price from the list passed in.
max - The most expensive price from the list passed in.
error - Any error values should there be issues with the list passed in.

Hint

You can create new errors using the error package and calling errors.New().

Debugging with the Python Debugger - PDB

Sat, 02 Sep 2017 13:35:28 +0100

In this tutorial we’ll be having a look at the Python Debugger, what it is and how you can use it to effectively debug your Python applications.

Knowing how to debug your code is an incredibly important tool in any programmers arsenal. Thankfully Python comes with the excellent PDB or Python DeBugger which allows us to step through our code and effectively work out what has gone wrong.

The official documentation for the Python Debugger can be found here: Python Debugger

Reading And Writing To Files in Go

Thu, 28 May 2026 12:00:00 +0000

Note: If you are working with structured data, you may also like Go JSON Tutorial.

The techniques we’ll cover here are file format-agnostic — you can use them to read and write .txt, .csv, .json, or any other file type. The only thing that differs between formats is how you parse or structure the data inside.

Reading Files

Use os.ReadFile to read the entire contents of a file into memory in one call.

Executing System Commands With Go

Sat, 07 Mar 2026 00:00:00 +0000

Last Updated - 7th March, 2026

In this tutorial, we are going to be taking a look at the os/exec package in the standard library and how we can use this to successfully execute system commands within our Go applications. We’ll cover modern Go 1.26 patterns and best practices for command execution, including timeout handling and security considerations.

Note - The official documentation for executing system commands can be found under the exec package: os/exec package.

Reading in Console Input in Go

Sat, 07 Mar 2026 00:00:00 +0000

This is a quick and simple tutorial on how to read in console text input into your Go (GoLang) program. This tutorial has been updated for Go 1.26 and covers modern approaches for console input. We’ll be creating the basis for a very simple shell that will take in all user input and simply echo it back to the user. We’ll focus on modern approaches using bufio.Scanner and fmt functions.

Challenge 08 - Check Permutations

Thu, 28 May 2020 21:08:18 +0100

👋 Welcome Gophers! In this Go challenge, you are going to be implementing a function that takes in two string values and checks to see if they are permutations of one another.

Example

If I have 2 strings, “abc” and “cba”, when I pass these strings into the function, it should return true as these two strings are permutations of each other.

Hints

You can iterate through all the characters in a string using the range keyword in a for loop

Part 7 - Uploading Images To Our App

Sun, 26 Jan 2020 18:44:50 +0100

In the last tutorial in this series, we successfully implemented a complete login/registration flow for our application that interfaces directly with an AWS Cognito UserPool.

In this tutorial, we’ll finally start implementing some of the basic functionality that our app will need to survive in the wild and become self-driven by our newly registered users. More specifically, we will be adding the frontend Upload component component that will do the job of talking to the upload API endpoint that we built and deployed in part 4 of this series.

Python Modules Tutorial

Mon, 28 Aug 2017 18:42:27 +0100

This tutorial was developed using Python version 3.6.

Larger Python projects require larger degrees of order and sub-dividing your project up into logical blocks can greatly improve the readability of your codebase. In Python we can do this sub-division using a concept using modules.

Say for instance you have a program that bought and sold widgets on the stock market. This project does a number of things:

It performs analysis of the widgets and returns recommendations as to whether to buy or sell these widgets
It performs the buying and selling of said widgets
It produces reports of the widgets it has bought and sold

In this scenario the code would be far too much for one file and as such breaking it up into multiple modules would make sense in this instance. We could have an analysis module, a trader module and a reports module.

Parsing JSON files With Go

Sat, 07 Mar 2026 21:07:11 +0100

Welcome all, in this tutorial, we are going to be taking a look at how you can read in JSON files, or JSON HTTP responses and parse them to your hearts desire.

JSON or Javascript Object Notation as it is short for, is a standard format for sending and receiving information. We could represent the same information with either XML or JSON, but JSON provides one advantage in the fact it is far more compact and in my personal experience, more readable.

Challenge 09 - 🔗 Singly Linked Lists

Sat, 30 May 2020 08:41:49 +0100

👋 Welcome Gophers! In this challenge, you will be implementing some of the basic functionality of a singly linked-list in Go! 💪

In this challenge, we will be attempted to implement the Add function of a singly linked list.

Linked Lists

Linked lists are a data structure we can utilize in order to represent a sequence of elements or nodes as they are called. Singly linked lists are a one way sequence where each node contains a pointer to the next node in the list.

Part 8 - Deploying our Imgur Clone

Sat, 08 Feb 2020 18:44:50 +0100

In this tutorial in the series, we are going to look at an incredibly important, but often overlooked aspect of project development and that is deploying our app in an automated fashion. The main goal for this tutorial is to show you how you can fully automate both your Vue.js and your Serverless deploys using Travis-CI.

The Importance of Automated Deployment

Being able to automatically and reliably deploy updates to your applications is hugely important regardless of what you are developing.

Python Project Layout Best Practices

Mon, 28 Aug 2017 18:47:50 +0100

This tutorial was built using Python 3.6. It should also be noted that these are opinions and to be taken with a grain of salt.

Structure is an incredibly important aspect of all projects and following a standard structure when it comes to designing your systems plays a huge part in making it more maintainable. By following standards you are essentially easing the job of new programmers coming on to a project as they’ll find it easier to navigate around and become comfortable with your systems.

Profile Guided Optimizations for Go Applications

Tue, 01 Aug 2023 20:52:32 +0100

The latest Go releases are absolutely stuffed with a number of fantastic new features, one of which, is the ability to significantly improve the performance of the hot paths within your applications using something called Profile Guided Optimizations.

Go isn’t generally considered a slouch when it comes to performance, however, this technique, also known as feedback-directed optimizations (FDO) - can help you to squeeze out every last ounce of performance out of your app which can be vital if you’re working in a high-performance domain.

Challenge 10 - Word Frequencies

Sun, 31 May 2020 18:22:08 +0100

👋 Welcome Gophers! In this challenge, you will be tasked with efficiently counting the word frequencies of a large body of text in Go!

You will have to implement a function which keeps track of the number of times a word appears in a body of text and then you will have to implement a further function which returns the top 5 most frequent words from highest to lowest.

View Solution

package main

import (
	"fmt"
	"sort"
	"strings"
)

type Word struct {
	Word string
	Frequency int
}

type ByFrequency []Word

func (p ByFrequency) Len() int {
	return len(p)
}

func (p ByFrequency) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p ByFrequency) Less(i, j int) bool {
	return p[i].Frequency > p[j].Frequency
}

func SortByFrequency(words []Word) []Word {
	sort.Sort(ByFrequency(words))
	return words
}

func CountWords(text string) map[string]int {
	frequency := make(map[string]int)

	for _, word := range strings.Split(text, " ") {

		if _, ok := frequency[word]; ok {
			frequency[word]++
		} else {
			frequency[word] = 1
		}

	}
	return frequency
}

func Top5Words(wordmap map[string]int) []Word {
	var words []Word
	for word, freq := range wordmap {
		words = append(words, Word{Word: word, Frequency: freq})
	}

	sort.Sort(ByFrequency(words))
	return words[:6]
}

func main() {
	fmt.Println("Word Frequency Test")

	text := `Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.`

	results := CountWords(text)
	MostCommon := Top5Words(results)

	fmt.Println(MostCommon)
}

Python Logging Best Practices

Sun, 13 Aug 2017 17:06:57 +0100

In this tutorial we’ll be looking at some of the best practices that you should be following when it comes to implementing logging in your Python programs.

This article was written against Python version 3.6

Why Do We Need Logging?

Logging is an incredibly important feature of any application as it gives both programmers and people supporting the application key insight into what their systems are doing. Without proper logging we have no real idea as to why our applications fail and no real recourse for fixing these applications.

Parsing XML Files With Go

Sun, 09 Apr 2017 21:07:45 +0100

In this tutorial we look at how you can effectively read in an XML file from the file system and then parse this file using Go’s “encoding/xml” Package. We’ll look at how you can traverse multiple nested xml elements and then we’ll simply print this out to our terminal window.

Our Example XML File

So to begin with, we’ll need an xml file that we can traverse.

An Introduction to Testing in Go

Sat, 07 Mar 2026 17:27:18 +0000

🚀 My new course - The Golang Testing Bible is out now and covers everything you need to get up and running creating tests for your Go applications!

Testing is hugely important in all software. Being able to ensure the correctness of your code and ensure that any changes you make don’t end up breaking anything else in different parts of your codebase is hugely important.

By taking the time to adequately test your go programs you allow yourself to develop faster with a greater sense of confidence that what you are developing will continue to work when you release it to production.

Making HTTP requests in Go

Fri, 16 Dec 2022 17:27:18 +0000

Welcome Gophers! In this tutorial, we are going to be taking a quick look at how we can make HTTP requests in Go!

In Go, we can use the net/http package in order to help us make our own HTTP requests.

Importing the Package

To use the net/http package in your Go program, you will need to import it first:

import "net/http"

Making a GET Request

The most basic type of HTTP request is a GET request. To make a GET request, you can use the http.Get function like so:

Retrying HTTP Requests in Go with retry-go

Fri, 16 Dec 2022 17:27:18 +0000

Welcome Gophers! In this quick tutorial, we are going to be looking at how we can easily retry HTTP requests in Go using the retry-go library.

Retrying Requests

The retry-go library is a convenient way to retry HTTP requests in Go with configurable options and callbacks.

import "github.com/avast/retry-go"

func sendRequest() error {
 var resp *http.Response
 err := retry.Do(
 func() error {
 var err error
 resp, err = http.Get("http://www.example.com/")
 return err
 },
 retry.Attempts(3),
 retry.OnRetry(func(n uint, err error) {
 log.Printf("Retrying request after error: %v", err)
 }),
 )
 if err != nil {
 return err
 }
 defer resp.Body.Close()
 // do something with the response
 return nil
}

In this example, the retry.Do function retries the HTTP GET request up to three times. If the request fails, the OnRetry hook is called, which logs the error. If the request still fails after three attempts, the sendRequest function returns the error.

Challenge 11 - Sets and Subsets

Mon, 01 Jun 2020 19:47:02 +0100

👋 Welcome Gophers! In this challenge, you are tasked with trying to implement a function that checks to see if a set is a sub-set of another set.

We’ll be carrying on the flying theme where the function takes in a slice of Flights and then checks to see if they exist within another slice of flights.

Hint

There are a number of ways to solve this. You may be able to use the reflect package or you may be able to serialize each flight and create a hash of them which you can store in a hash.

Python Decorators Tutorial

Tue, 08 Aug 2017 18:55:48 +0100

This Tutorial was written using Python 3.6

In this tutorial, I am going to be demonstrating the wonderful concept that is Python decorators. We’ll look at the various attributes of Python that make writing your own decorators fairly simple and then we’ll cover some cool examples as to how you can use decorators to improve the performance of some types of applications.

Video Tutorial

If you prefer, feel free to check out the video version of this course, like and subscribe to my channel for more Python related video content!

Challenge 12 - Armstrong Numbers

Tue, 02 Jun 2020 18:12:42 +0100

👋 Welcome Gophers! In this challenge, you are tasked with implementing a function that checks to see whether a number is an armstrong number.

Armstrong Numbers

Armstrong Numbers - An Armstrong number is a 3-digit number such that each of the sum of the cubes of its digits equal the number itself:

View Solution

package main

import "fmt"
import "math"

type MyInt int

func (nptr *MyInt) IsArmstrong() bool {
 n := *nptr
 if n > 999 && n < 100 {
 return false
 }
 
 n1 := float64(n / 100)
 n2 := float64((n%100) / 10)
 n3 := float64(n % 10)
 
 calculated := math.Pow(n1, 3) + math.Pow(n2, 3) + math.Pow(n3, 3)
 return float64(n) == calculated
}

func main() {
 fmt.Println("Armstrong Numbers")

 var num1 MyInt = 371
 fmt.Println(num1.IsArmstrong())
}

Advanced Go Testing Tutorial

Wed, 29 Aug 2018 21:57:53 +0100

🚀 My new course - The Golang Testing Bible is out now and covers everything you need to get up and running creating tests for your Go applications!

Welcome fellow coders! In this tutorial, we are going to be taking a look at a selection of more advanced testing practices used by the likes of the Go core language developers and in popular production-level tools.

I feel this approach, of actually studying what has been done in a production system, will hopefully give you some insight into the best ways to test your own production-level Go programs.

Python Generators Tutorial

Mon, 12 Jun 2017 14:26:02 +0000

This tutorial was built using Python 3.6

In this tutorial I’m aiming to help demystify this concept of generators within the Python programming language. We’ll look at what generators are and how we can utilize them within our python programs.

What Are Generators?

Generators are functions that can return multiple values at different times. These are iterators that we can subsequently iterate over in a variety of different ways.

The Go init Function

Fri, 20 May 2022 10:44:54 +0100

There are times, when creating applications in Go, that you need to be able to set up some form of state on the initial startup of your program. This could involve creating connections to databases, or loading in configuration from locally stored configuration files.

In this tutorial, we’ll be looking at how you can use this init() function to achieve this goal and we’ll also be taking a look at why this might not necessarily be the best approach to instantiating your components.

Challenge 13 - Smallest Difference between Ints

Wed, 03 Jun 2020 19:55:24 +0100

👋 Welcome Gophers! In this challenge, you are tasked with finding the smallest difference between two slices of int values.

Example: Let’s say I have 2 int arrays; [1, 2] and [4, 5]. The function should return the smallest difference which would be the difference between 2 and 4.

View Solution

package main

import "fmt"

import "sort"

func CalcSmallestDifference(arr1, arr2 []int) int { 
 sort.Ints(arr1)
 sort.Ints(arr2)
 
 greater1 := arr1[len(arr1)-1]
 smaller2 := arr2[0]
 
 if (greater1 >= smaller2) {
return 0
 } 
 return smaller2 - greater1
}

func main() {
 fmt.Println("Smallest Difference Challenge")

 arr1 := []int{9, 8, 7, 6}
 arr2 := []int{7, 3, 2, 5}

 smallestDiff := CalcSmallestDifference(arr1, arr2)
 fmt.Println(smallestDiff)
}

An Intro to Go Dep

Sun, 18 Feb 2018 09:16:39 +0000

In this tutorial, we are going to look at how you can use the Dep tool in go to manage your Go’s project dependencies.

Note - This article covers dep, which is now deprecated. Go 1.11+ uses go mod (Go Modules) for dependency management, which is the recommended approach for modern Go projects. See An Intro to Go Modules for the current standard.

Why dep?

The dep tool is the “official experiment” dependency management tool for the go programming language. It helps you to manage the ever-growing list of dependencies your project needs to maintain without a lot of overhead and it can pin you to specific versions of dependencies to ensure stability in your systems.

Python Iterator Tutorial

Sun, 03 Sep 2017 17:58:24 +0100

This tutorial was built using Python 3.6

In this tutorial we’ll be looking at what iterators are with Python. We’ll also be looking at how we can effectively work with them and improve our Python programs using them.

What Are Iterators?

Iterators are cool in the sense that they allow us to step over every item in an array, object or file and perform work on each item. For example, we could take the string test and use an iterator to step over every character element within that string.

Challenge 14 - Leap Years

Thu, 04 Jun 2020 21:22:55 +0100

👋 Welcome Gophers, in this challenge, you are tasked with implementing a function that returns whether or not a year is in fact a leap year.

View Solution

package main

import "fmt"

func CheckLeapYear(year int) bool {
 // If a year is multiple of 400, 
 // then it is a leap year 
 if year % 400 == 0 {
 	return true; 
 }

 // Else If a year is muliplt of 100, 
 // then it is not a leap year 
 if year % 100 == 0 {
 	return false; 
 }

 // Else If a year is muliplt of 4, 
 // then it is a leap year 
 if year % 4 == 0 {
 	return true; 
 }
 return false; 
}

func main() {
 fmt.Println("Check Leap Year")

 year := 2020
 fmt.Println(CheckLeapYear(year))
}

An Introduction to Benchmarking Your Go Programs

Sat, 10 Feb 2018 08:48:40 +0000

In this article, we are going to be having a look at benchmarking. More specifically, we are going to be looking at how you can benchmark your Go-based programs.

In times where performance is important, being able to benchmark how your program performs and analyze where potential bottlenecks are, is really valuable. By understanding where these bottlenecks lie, we can more effectively determine where to focus our efforts in order to improve the performance of our systems.

Getting Started With PyUnit Testing

Sun, 19 Nov 2017 10:18:54 +0000

This tutorial is currently under construction.

This tutorial was built using Python 3.6

If you are starting to improve your Python development skills, the one aspect that must be up to scratch is your ability to test your code. Unit testing your code can help to improve the confidence you have whenever you are trying to make any patches, bug fixes or just changes in general.

If your tests adequately test that your code behaves the way you expect it to, whenever you make a change, you can retest and ensure that your code still behaves the way you expect it with your incorporated changes. If the tests fail then you know that you will have to make further changes until your tests do pass.

How To Consume Data From A REST HTTP API With Go

Sun, 05 Jun 2022 08:56:56 +0100

Note - For a tutorial on how to build a RESTful API in Go, click here.

In this tutorial, I’m going to demonstrate how we can consume an already running RESTful API using Go. There are currently hundreds of open REST APIs out there that are just waiting to be consumed and turned into something more meaningful. Todd Motto has put together quite an active repo on GitHub that lists all the public APIs available for consumption. He has categorized them so that we can easily drill down to what we want to check out. You can find that here.

Challenge 15 - Repeating Letters

Fri, 05 Jun 2020 17:56:04 +0100

👋 Welcome Gophers! In this challenge, you are tasked with implementing a function DoubleChars which will take in a string and then return another string which has every letter in the word doubled.

View Solution

package main

import "fmt"

func DoubleChars(original string) string {
 endString := make([]rune, 0, len(original)*2)
 for _, c := range original {
 endString = append(endString, c, c)
 }
 return string(endString)
}

func main() {
 fmt.Println("Repeating Letters Challenge")

 original := "gophers"
 doubled := DoubleChars(original)
 fmt.Println(doubled) // ggoopphheerrss
}

Go Maps Tutorial

Sat, 29 Jun 2019 23:00:00 +0000

In this tutorial, we are going to look at maps in Go and how you can use them to achieve world domination!

We are going to be covering just about everything you need to know about maps to get started using them within your own Go applications. We are going to be looking at all of the various ways you interact with maps in Go and by the end of this tutorial, you will be a master when it comes to using them.

Creating a RESTful API With Go

Sat, 07 Mar 2026 08:45:15 +0100

If you are writing any form of web application, then you are most likely interfacing with 1 or more REST APIs in order to populate the dynamic parts of your application and to perform tasks such as updating or deleting data within a database.

In this tutorial, you are going to be building a fully-fledged REST API that exposes GET, POST, DELETE and PUT endpoints that will subsequently allow you to perform the full range of CRUD operations.

Challenge 16 - Odd or Even Factors

Sun, 07 Jun 2020 19:04:19 +0100

👋 Welcome Gophers! In this challenge, you will be tasked with implementing a function that will return either “odd” or “even” depending on whether or not a number has an odd or an even number of factors.

View Solution

package main

import "fmt"
import "math"

func OddEvenFactors(num int) string {
 factors := CheckFactors(num)
 if len(factors) % 2 == 0 {
 return "even"
 }
 return "odd"
}

func CheckFactors(num int) []int {
 factors := []int {1, num}
 limit := int(math.Ceil(float64(num)/2))
 for i := 2; i <= limit; i++ {
 if num % i == 0 {
 factors = append(factors, i) 
 }
 }
 return factors
}

func main() {
 fmt.Println("Odd or Even Factors")

 numFactors := OddEvenFactors(23)
 fmt.Println(numFactors) // "even"

 numFactors = OddEvenFactors(36)
 fmt.Println(numFactors) // "odd"
}

Building a Web Server in Go with net/http

Wed, 27 May 2026 12:00:00 +0000

Building a web server is one of the best first projects when learning a new language — it touches routing, request handling, and the standard library all at once.

In Go, the net/http package makes this surprisingly straightforward. If you’ve used Node’s Express or Python’s Flask, you’ll notice familiar patterns.

We’ll build up from a minimal handler, add a mutex-guarded counter, serve static files, and finally secure the server with HTTPS.

Challenge 17 - Decode the Secret

Mon, 08 Jun 2020 21:23:28 +0100

👋 Welcome Gophers! In this challenge, you are tasked with decoding the secret message.

You will need to implement the DecodeSecret function which will take in a string that has been encoded using base64 encoding and decode this string.

This decoded string will be the result of a caesar cipher which has shifted all of the characters of the string up by 1 place. So you will have to ensure that when you return the result, it also decodes this cipher.

Challenge 18 - Min Rotations

Tue, 09 Jun 2020 20:36:23 +0100

👋 Welcome Gophers! In this challenge, you will be tasked with finding out how many rotations an ordered int slice has undergone and shifted by.

Examples:

arr := []int{1, 2, 3, 4, 5}
MinRotations(arr) // returns 2

arr := []int{3, 4, 5, 1, 2}
MinRotations(arr) // returns 3

See the Solution

View Solution

package main

import "fmt"

func MinRotations(array []int) int {
	// Implement me :)
	size := len(array)
	if size <= 1 {
		return 0
	}

	lowIndex := 0
	middleIndex := 0
	highIndex := size - 1
	for array[lowIndex] > array[highIndex] {
		middleIndex = (lowIndex + highIndex) / 2
		if array[middleIndex] > array[highIndex] {
			lowIndex = middleIndex + 1
		} else {
			highIndex = middleIndex
		}
	}
	return lowIndex
}

func main() {
	fmt.Println("Min Rotation Challenge")

	testArr := []int{15, 18, 2, 3, 6, 12}
	min := MinRotations(testArr) // returns 2
	fmt.Println(min)

	testArr2 := []int{7, 9, 11, 12, 5}
	min2 := MinRotations(testArr2) // return 4
	fmt.Println(min2)

}

Building a Network Command Line Interface in Go

Sun, 29 Jul 2018 09:41:15 +0100

In this article, we are going to be building a very simple Command Line Interface in Go using the urfave/cli package available on Github here: https://github.com/urfave/cli.

I’ve been doing one or two domain migrations across various hosting providers recently and thought it would be a cool idea to build a tool or program that could be used to query things like the Nameservers of a website, the CNAMEs, the IP addresses and so on.

Challenge 19 - Difference Between Squares

Sun, 24 Nov 2019 11:05:52 +0000

In this challenge, you are going to implement the DiffSquares function so that it returns the difference between the first number squared minus the second number squared.

5^2 - 4^2 = 9

If you require a hint as to how this is done, please click below:

Hint

You can calculate powers of numbers in Go using the math.Pow function. You can read more about this here: Math Pow

View Solution

package main

import (
	"fmt"
	"math"
)

func DiffSquares(n, m int) int {
	x := math.Pow(float64(n), 2)
	y := math.Pow(float64(m), 2)
	return int(x) - int(y)
}

func main() {
	fmt.Println("Calculate The Difference of Squares")
	result := DiffSquares(5, 4)
	fmt.Println(result)
}

Writing A Twitter Bot in Go

Sun, 09 Apr 2017 21:33:19 +0100

In this tutorial I’m going to be demonstrating how to build a twitter bot using go-twitter, a popular Go client library for the Twitter API.

I’ll be demonstrating how you can build a go based twitter bot that will be able to do such things as automatically reply to tweets and favorite tweets that contain a specific hashtag.

Setting Up Your Project

Note - We’ll be using go modules, which is now the standard dependency management tool in Go 1.11 and later

Challenge 20 - Finding the nth Triangular Number

Sun, 24 Nov 2019 11:05:52 +0000

In this challenge, you are going to implement the TriangularNumbers function which takes in n and returns the nth triangular number.

n = 1
result = 1

n = 3
result = 6

See the Solution

View Solution

package main

import "fmt"

func TriangularNumber(n int) int {
 return (n * (n+1))/2
}

func main() {
 fmt.Println("Returning the 'nth' triangular number")

 number := TriangularNumber(3)
 fmt.Println(number) // '6'

}

Python Based Lambda Tutorial

Sat, 24 Feb 2018 10:23:36 +0000

If you’ve been following my Medium Blog recently, you’ll know that I’m a huge fan of Serverless and I genuinely believe that it will start to seriously take off in terms of popularity in the years to come.

In this tutorial, we are going to be writing a very simple Python based AWS Lambda function that we’ll then deploy using the serverless.com CLI.

Installing Serverless

In order to install the serverless CLI you can do the following:

Go ORM Tutorial

Wed, 07 Feb 2018 20:57:06 +0000

In this tutorial, we are going to look at how we can use the Go-ORM or GORM to interact with a sqlite3 database in a simple manner.

ORMs or Object Relationship Managers act almost as brokers between us developers and our underlying database technology. They allow us to essentially work with objects, much as we normally would and then save these objects without having to craft complex SQL statements.

They effectively reduce the complexity of our codebase in scenarios where you don’t wish to work with SQL but need a database.

Challenge 21 - JSON and Stock Dividends

Sun, 02 Aug 2020 21:08:18 +0100

👋 Welcome Gophers! In this Go challenge, you are going to be working with JSON data and implementing a function that takes in a JSON string full of stock quotes and returns the one with the highest dividend return.

You will need to implement the HighestDividend function so that it takes in a JSON string. You will then need to somehow convert this JSON string into something you can traverse in Go using the encoding/json package.

Go MySQL Tutorial

Sun, 09 Apr 2017 21:28:15 +0100

As you continue your Golang learning journey, it becomes almost inevitable that you will have to interact with some form of database.

In this tutorial I’ll be demonstrating how you can connect to a MySQL database and perform basic SQL statements using Go.

Why MySQL?

MySQL is one of the most well-known and well-used database technologies available to developers at the present point in time. It has an absolutely massive community around it and it’s quite possibly powering half the web as the main database technology for Wordpress.

Concurrency in Go: Goroutines Explained

Wed, 27 May 2026 12:00:00 +0000

Go is a highly performant language built for concurrency. It redefines concurrent programming through goroutines and channels — lightweight primitives managed by the Go runtime.

Using goroutines turns a sequential program into a concurrent one without managing threads or thread-pools.

But concurrency comes with dangers. Before adding the go keyword to every function call, it’s worth understanding how goroutines work and where they can go wrong.

In this tutorial, we’ll look at how to use goroutines in Go programs and improve the performance of your applications.

Challenge 22 - Largest Pandigital Prime

Tue, 09 Jun 2020 20:36:23 +0100

Problem Attribution - This challenge was inspired by Problem 41 on Project Euler

👋 Welcome Gophers! In this challenge, you are tasked with implementing the LargestPandigitalPrime function which will return the largest possible pandigital prime number.

Pandigital Primes

An n-digit number is pandigital if it makes use of all the digits 1 to n exactly ones.

pandigital := LargestPandigitalPrime() // returns largest pandigital prime

View Solution

package main

import (
	"fmt"
	"math"
	"strconv"
)

func notPrime(n int) bool {
	if n&2 == 2 {
		return false
	}
	if (n-1)%6 == 0 {
		return false
	}
	if (n+1)%6 == 0 {
		return false
	}
	return true
}

func isPrime(n int) bool {
	if notPrime(n) {
		return false
	}
	max := int(math.Ceil(math.Sqrt(float64(n))))
	for i := int(3); i < max; i += 2 {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func atoi(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func permute(s string) []string {
	if len(s) == 1 {
		return []string{s}
	}

	perms := []string{}
	head := string(s[0])
	tail := s[1:]

	for _, perm := range permute(tail) {
		for i := 0; i < len(s); i++ {
			newperm := perm[:i] + head + perm[i:]
			perms = append(perms, newperm)
		}
	}
	return perms
}

func LargestPandigitalPrime() int {
	max := 0
	digits := "7654321"
	for i := 0; i < len(digits); i++ {
		for _, perm := range permute(digits[i:]) {
			i := atoi(perm)
			if isPrime(i) {
				if i > max {
					max = i
				}
			}
		}
		if max > 0 {
			break
		}
	}
	return max
}

func main() {
 fmt.Println("Pandigital Primes")

 pandigitalPrime := LargestPandigitalPrime()
 fmt.Println(pandigitalPrime)
}

Go Mutex Tutorial

Sat, 25 Aug 2018 14:21:04 +0100

The use of Go when programming highly concurrent applications doesn’t prevent you from writing a system that can feature race conditions. These race conditions can cause unexpected issues with your systems that are both hard to debug and at times, even harder to fix.

Thus, we need to be able to write Go programs that can execute concurrently in a safe manner without impacting performance. This is where the mutex comes into play.

Go Channels Tutorial

Sat, 07 Mar 2026 14:47:06 +0100

In this tutorial, we are going to be looking at how you can use channels within your Go-based applications.

Channels are pipes that link between goroutines within your Go based applications that allow communication and subsequently the passing of values to and from variables.

They are incredibly handy and can help you craft incredibly high performance, highly concurrent applications in Go with minimal fuss compared to other programming languages. This was by no means a fluke, when designing the language, the core developers decided that they wanted concurrency within their language to be a first class citizen and to make it as simple to work with as possible, without going too far and not allowing developers the freedom they need to work in.

Working with Websockets and Socket.IO in Go - Tutorial

Wed, 23 Aug 2017 19:29:11 +0100

Note - This tutorial was written using Go version 1.9 and googollee/go-socket.io

Websockets are something I find interesting in the sense that they provide us with an alternative option to communication between applications as opposed to the standard RESTful API solution. With Sockets we can do cool things such as real-time communication between thousands to hundreds of thousands of different clients without having to incur the expense of hundreds of thousands of RESTful API calls hitting our servers every minute.

Go Protocol Buffer Tutorial

Sat, 01 Sep 2018 18:53:06 +0100

Welcome fellow coders! In this tutorial, we are going to be looking at how you can utilize the Protocol Buffers data format within your Go-based applications. We’ll be covering what the data format is, and why it is an improvement over more traditional data formats such as XML or even JSON. And we’ll dive into a simple example to get us up and running before trying our hands at a more complex example.

Go WebAssembly Tutorial - Building a Calculator Tutorial

Sat, 25 Aug 2018 15:54:23 +0100

Update - The code in this tutorial has been updated to work with the breaking changes in Go v1.12

Welcome All! With Go v1.11 having just been released with an experimental port to WebAssembly included, I thought it would be awesome to see how we can write our own Go programs that compile straight to WebAssembly!

So, in this article, we are going to be building a really simple calculator to give us an idea as to how we can write functions that can be exposed to the frontend, evaluate DOM elements and subsequently update any DOM elements with the results from any functions we call.

Go Oauth2 Tutorial

Mon, 10 Sep 2018 20:04:14 +0100

Welcome fellow coders! In this tutorial, we are going to be taking a look at how you can implement your own OAuth2 Server and client using the go-oauth2/oauth2 package.

This is without a doubt one of the most requested topics from commentors on my YouTube videos and it’s certainly something that I myself find incredibly interesting.

Security is without doubt a very important feature for any public and even private facing service or API and it’s something that you need to pay a lot of attention to in order to get it right.

Go Face Recognition Tutorial - Part 1

Thu, 27 Sep 2018 10:48:51 +0100

The whole area of Face Recognition is something I love reading about. Implementing a facial recognition system yourself makes you sound like you are Tony Stark and you can use them for a variety of different projects such as an automatic lock on your door, or building a surveillance system for your office to name but a few.

In this tutorial, we are going to be building our own, really simple face recognition based system in Go using a few existing libraries. We’ll start by doing simple face recognition on still images and seeing how that works and we’ll then be expanding upon this to look into real-time face recognition on video feeds in part 2 of this mini-series.

Go Unsafe Package Tutorial

Sat, 06 Oct 2018 14:50:30 +0100

In this tutorial, we’re going to explore Go’s unsafe package - a powerful but dangerous set of tools that let you work directly with memory. Before we dive in, let’s be clear: the unsafe package bypasses Go’s type safety and memory safety guarantees. You should rarely need it in your day-to-day code, but when you do, it’s invaluable. Let’s see what we can do with it.

Introduction to unsafe

The unsafe package exists because sometimes you need to break the rules. Maybe you’re interfacing with C code via cgo, implementing a high-performance serialization library, or optimizing a critical path. The unsafe package gives you access to the underlying memory layout of your data structures.

Go Encryption and Decryption using AES - Tutorial

Tue, 20 Nov 2018 07:56:42 +0000

Objectives

By the end of this tutorial, you will be able to…

Encrypt text using the AES - Advanced Encryption Standard in Go
We’ll then look at writing this encrypted message to a file
Finally we’ll look at how we can decrypt this message using a shared secret

From this, you should be able to build your own simple encryption systems that can do various things like, encrypt files on your file system and protect them with a passphrase only you know or add simple encryption to various parts of the systems that you are working on.

Building a Solid Continuous Integration Pipeline with TravisCI for Your Go Projects

Tue, 16 Oct 2018 20:10:30 +0100

Note - Travis CI has significantly reduced its free tier for open-source projects since this article was written. For a modern alternative, check out our guide on GitHub Actions for Go Projects which is now the recommended CI/CD approach for Go projects hosted on GitHub.

So, I recently partook in Hacktoberfest which is an event that helps to support thousands of different Open Source projects. Usually, I tend to get caught up in other projects or can’t find the time or make up a hundred other excuses for not taking part.

Cloud Development

Sun, 08 Jul 2018 09:25:32 +0100

Course Outline

The world is moving towards using the cloud. It’s undeniable. We have thousands of companies, at all levels of development, starting to look at, and investigate the advantages of migrating their software to become cloud native and to leverage the services of providers such as AWS, Microsoft Azure and Google’s own Cloud platform.

These companies are moving away from the burden of maintaining their own Physical infrastructure and by migrating their systems to the cloud, and subsequently, they can leverage hundreds, if not thousands of years of collective development expertise supporting the machines and systems they run on top of and focus more on delivering key functionality to their customers.

Computer Science Fundamentals

Sun, 08 Jul 2018 09:25:32 +0100

Course Outline

In this course, we are going to look at the basic data structures and how you can use them to implement the various fundamental sorting algorithms!

Go

Sun, 08 Jul 2018 09:25:32 +0100

Course Outline

In this course, we are going to be taking a look at how you can get started with the Go programming language.

Go Challenges - Interested in learning Go through practical examples? Then check out my list of Go Challenges that are now available on the site!

Caching in System Design

Sat, 20 Jun 2026 12:00:00 +0000

Caching trades memory and freshness for speed and reduced load. By storing a copy of frequently accessed data closer to the consumer, you serve repeated requests without touching the primary data store.

At scale, caching is one of the highest-leverage tools available. A database query that takes 20ms on a cold path takes under 1ms when served from Redis. That difference compounds across millions of requests per day.

Caches live at many layers. Client-side caches store data in the browser or mobile app. CDN caches hold static assets and rendered pages at the edge.

Consistency and the CAP Theorem: A System Design Guide

Sat, 20 Jun 2026 12:00:00 +0000

The CAP theorem is the first concept most interviewers reach for when probing your knowledge of distributed systems. It frames every data store decision you will ever make at scale.

Proposed by Eric Brewer in 2000 and later formalised as a theorem, CAP says a distributed data store can guarantee at most two of three properties: Consistency, Availability, and Partition tolerance. You cannot have all three.

This guide explains what each property actually means, what the real tradeoff looks like in practice, and how to talk about it confidently when an interviewer asks.

Database Replication Explained

Sat, 20 Jun 2026 12:00:00 +0000

Database replication is the process of keeping copies of the same data on multiple nodes. It is one of the most fundamental tools for building systems that are fast, resilient, and always on.

Replication solves three problems at once. It scales reads by spreading queries across nodes, improves availability by removing single points of failure, and improves durability so data survives the loss of any one machine.

This guide explains the core patterns, the real tradeoffs, and how to reason about them clearly in an interview.

Database Sharding and Partitioning

Sat, 20 Jun 2026 12:00:00 +0000

Vertical scaling - adding more CPU, RAM, or faster disks to one machine - has hard limits. Once you hit them, no single node can hold all your data or serve all your writes.

Sharding solves this by splitting one dataset across many nodes. Each node holds a subset of the rows, so the write load and storage are distributed rather than concentrated.

The terms are easy to confuse. Partitioning means dividing a table into logical segments; sharding means spreading those partitions across separate physical machines or nodes. Sharding is partitioning taken to a distributed level.

Message Queues in System Design

Sat, 20 Jun 2026 12:00:00 +0000

When services call each other synchronously, they are tightly coupled. If the downstream service is slow, the caller blocks. If it is down, the caller fails.

A message queue breaks that coupling by placing an asynchronous buffer between the two. The producer writes a message and moves on immediately. The consumer reads it whenever it is ready.

This decoupling is what makes queues one of the most common components in large-scale system design.

How to Make Your Pull Requests Easy to Review

Wed, 17 Jun 2026 12:00:00 +0000

Code review is about to become your team’s biggest bottleneck. Everyone is shipping AI-generated pull requests now, which means three times the diffs hitting the same number of reviewers. The queue grows, nothing merges, and your velocity quietly grinds to a halt. In this tutorial we’ll fix that from the author’s side: instead of hoping a human catches everything, you bake a set of adversarial review rules into your own change before anyone else looks at it. We’ll cover three rules - keep the diff small, attack your own code, and ship observability - with Go examples for each.

MCP Server Security in Go — Hardening Your Server

Wed, 10 Jun 2026 12:00:00 +0000

In Building an MCP Server in Go we built a small Model Context Protocol server that exposed a tool to an AI assistant. In this tutorial we’re going to attack one — and then harden it.

That framing matters. An MCP server sits between an AI model and your real filesystem, your APIs, and your data. And the thing deciding what arguments hit your tools is a language model, which can be manipulated by anything it has read. So the job is the same one web developers have had for twenty years: treat input as untrusted, sanitise output, and grant the least privilege you can get away with.

Build Your First AI Agent in Go with the ADK

Tue, 09 Jun 2026 12:00:00 +0000

Google’s Agent Development Kit (ADK) just got a Go version, and in this tutorial we’re going to use it to build your first AI agent from scratch. It’s a surprisingly small amount of code: a Gemini model doing the thinking, an agent wrapping it with an instruction, a session to hold the conversation, and a runner to drive everything. By the end you’ll have a working agent that answers a question in your terminal — and you’ll understand each of the four pieces well enough to start bending them to your own purposes.

Building an MCP Server in Go

Sun, 07 Jun 2026 12:00:00 +0000

In this tutorial, we’re going to build a Model Context Protocol (MCP) server in Go from scratch. MCP is the standard that lets AI assistants like Claude call out to your own code — your APIs, your databases, your search indexes — in a consistent way. By the end you’ll have a small but complete server that exposes a search_tutorials tool, handles tool calls, and serves over stdio so any MCP client can connect to it.

Arrays & Slices

Sat, 06 Jun 2026 11:00:00 +0000

Adventurers need to carry their spoils. A slice is Go’s flexible, growable list. You can create one with a literal, index into it, and grow it with append:

party := []string{"Elara", "Aragorn"}
party = append(party, "Gimli") // [Elara Aragorn Gimli]
fmt.Println(party[0]) // Elara

(An array has a fixed size, like [3]string{...}; a slice wraps an array and can grow — slices are what you’ll use almost all the time.)

Your Quest

Add "potion" to the backpack slice with append, then print the whole backpack.

Capstone: The Final Battle

Sat, 06 Jun 2026 11:00:00 +0000

This is it, adventurer — the final battle, and the end of your journey through Go. This capstone weaves together everything you’ve forged along the way: a struct for your combatants, a method with a pointer receiver to land blows, a slice of monsters, and nested loops to see the fight through.

The hero faces a line of monsters. Each must be worn down to 0 HP before moving to the next. (These monsters have Atk: 0, so the hero fights on unscathed — claim your victory.)

Channels

Sat, 06 Jun 2026 11:00:00 +0000

Goroutines need a safe way to talk to each other. A channel is a typed pipe: one goroutine sends a value with ch <- v, another receives it with <-ch.

ch := make(chan int)
go func() { ch <- 42 }() // send
n := <-ch // receive (blocks until a value arrives)

Sends and receives block until the other side is ready, which neatly synchronises the two goroutines — no locks required.

Your Quest

Launch a goroutine that sends "Victory!" into the messages channel. The <-messages receive already in place will print it.

Constants & iota

Sat, 06 Jun 2026 11:00:00 +0000

Some values should never change mid-quest — the size of your backpack, the name of your guild. For these, Go gives you const:

const maxInventory = 10

When you need a run of related constants, iota numbers them for you, starting at 0 and incrementing for each line:

const (
 Bronze = iota // 0
 Silver // 1
 Gold // 2
)

Your Quest

Define a constant block using iota for three ranks — Novice, Squire, and Knight — so that Knight has the value 2.

Defer

Sat, 06 Jun 2026 11:00:00 +0000

defer schedules a call to run when the surrounding function returns — perfect for cleanup you don’t want to forget (closing a file, releasing a lock, snuffing a torch).

func readScroll() {
 defer fmt.Println("scroll rolled back up")
 fmt.Println("reading the scroll...")
}

Deferred calls run in LIFO order — the last one deferred runs first. So if you defer two things, they unwind in reverse.

Your Quest

Add a deferred print of Torch extinguished. Because deferred calls run last and in reverse order, the output should be:

Error Handling

Sat, 06 Jun 2026 11:00:00 +0000

Go doesn’t use exceptions. Instead, functions that can fail return an error as their last value, and you check it right away. This is the famous if err != nil idiom:

result, err := doRisky()
if err != nil {
 fmt.Println("it failed:", err)
 return
}
// safe to use result here

A nil error means success. You create errors with errors.New("message") or fmt.Errorf("got %d", n).

Your Quest

drink(0) returns an error. Check err: if it’s not nil, print the error; otherwise print Potion drunk!.

For Loops

Sat, 06 Jun 2026 11:00:00 +0000

Go keeps things simple: it has exactly one loop keyword, for, which covers every looping need. The classic three-part form has an init, a condition, and a post statement:

for i := 0; i < 3; i++ {
 fmt.Println("swing", i)
}

Drop the init and post and it behaves like a while:

for health > 0 {
 health -= 10
}

And for ... range walks over a slice or map (you’ll use this a lot soon):

for index, item := range backpack {
 fmt.Println(index, item)
}

Your Quest

Use a for loop to print the numbers 1 to 5, one per line.

Functions Revisited

Sat, 06 Jun 2026 11:00:00 +0000

Functions are how you package up a spell to cast again and again. You’ve called them already — now let’s wield them properly. A Go function declares its parameters and its return type(s):

func heal(amount int) int {
 return amount * 2
}

A real strength of Go is multiple return values — perfect for returning a result and a status together:

func divide(a, b int) (int, bool) {
 if b == 0 {
 return 0, false
 }
 return a / b, true
}
result, ok := divide(10, 2)

You can even name the return values for clarity (func attack() (damage int, crit bool)), though we’ll keep it simple here.

Goroutines

Sat, 06 Jun 2026 11:00:00 +0000

A goroutine is a lightweight thread of execution. Put go in front of a function call and it runs concurrently, while the rest of your code carries on:

go scout() // runs in the background

The catch: main won’t wait for goroutines on its own — if it returns, they’re cut short. A sync.WaitGroup lets you wait: Add how many you expect, Done as each finishes, and Wait blocks until the count hits zero.

Hello, World

Sat, 06 Jun 2026 11:00:00 +0000

Every great adventure begins with a single step. In Go, that step is a main function inside the main package — the entry point the Go runtime calls when your program starts.

package main

import "fmt"

func main() {
 fmt.Println("Hello, World!")
}

package main marks this as a runnable program, import "fmt" pulls in Go’s formatting package, and fmt.Println prints a line to the console.

Your Quest

Complete the main function so the program prints exactly:

If / Else Conditionals

Sat, 06 Jun 2026 11:00:00 +0000

Every adventurer must make decisions. In Go, if runs a block only when its condition is true, and else covers the other case:

if gold >= 100 {
 fmt.Println("You can afford the sword.")
} else {
 fmt.Println("Keep saving, adventurer.")
}

Conditions use comparison operators (==, !=, <, >, <=, >=) and can be combined with && (and), || (or), and ! (not). You can chain checks with else if.

Your Quest

The hero’s health is 30. Print Retreat! if health is below 50, otherwise print Charge!.

Interfaces

Sat, 06 Jun 2026 11:00:00 +0000

An interface describes what a type can do, not what it is — a contract of method signatures:

type Attacker interface {
 Attack() int
}

Any type that has those methods satisfies the interface implicitly — there’s no implements keyword. If it has an Attack() int method, it is an Attacker. This lets you write code against behaviour, so a Goblin, a Dragon, or a Slime can all be passed wherever an Attacker is expected.

Maps

Sat, 06 Jun 2026 11:00:00 +0000

Sometimes a list isn’t enough — you want to look things up by name. A map stores key/value pairs:

prices := map[string]int{"sword": 100, "shield": 75}
prices["bow"] = 50 // add or update
fmt.Println(prices["sword"]) // 100

Reading a missing key returns the value type’s zero value. To tell “missing” from “zero”, use the comma-ok idiom:

qty, ok := prices["axe"] // qty=0, ok=false

Your Quest

Add 5 "arrows" to the inventory map, then print the number of arrows.

Expected output:

Hint

inventory["arrows"] = 5, then fmt.Println(inventory["arrows"]).

Methods

Sat, 06 Jun 2026 11:00:00 +0000

A method is a function attached to a type via a receiver in front of its name:

func (m Monster) Describe() string {
 return m.Name + " lurks nearby"
}
goblin.Describe()

The receiver can be a value (m Monster) or a pointer (m *Monster). Use a pointer receiver when the method needs to modify the struct — a value receiver works on a copy, so changes wouldn’t stick.

func (m *Monster) TakeHit(dmg int) {
 m.HP -= dmg // mutates the original
}

Your Quest

Add a method Heal with a pointer receiver (*Hero) that adds 10 to the hero’s HP.

Pointers

Sat, 06 Jun 2026 11:00:00 +0000

A pointer holds the memory address of a value rather than a copy of it. Two operators do the work:

&x takes the address of x.
*p dereferences the pointer p — reading or writing the value it points at.

hp := 100
p := &hp // p points at hp
*p = 80 // changes hp through the pointer
fmt.Println(hp) // 80

Pointers are how a function changes a caller’s variable instead of a copy — exactly what pointer receivers did in the last lesson.

Quest: Hero vs Monster

Sat, 06 Jun 2026 11:00:00 +0000

The moment of combat is here. This quest brings together Module 5: a struct for the combatant, a method with a pointer receiver to change its state, and repeated calls to whittle the monster down.

Your Quest

Call TakeDamage(12) on the monster twice, then print its remaining HP. Starting at 30, two 12-damage hits leave:

Hint

monster.TakeDamage(12) twice (Go automatically takes the monster’s address for the pointer receiver), then fmt.Println(monster.HP).

Quest: The Character Sheet

Sat, 06 Jun 2026 11:00:00 +0000

Time to put your training to the test, adventurer. You’ve learned short variables, long-hand var declarations with explicit types, and constants. This quest combines all three.

fmt.Printf lets you build a formatted string using verbs: %s for strings and %d for integers. End with \n for a newline.

fmt.Printf("%s dealt %d damage\n", attacker, damage)

Your Quest

Using the name, class, level, and startingGold values already defined, print a single line that reads exactly:

Quest: The Dungeon Crawl

Sat, 06 Jun 2026 11:00:00 +0000

Time to descend into the dungeon, adventurer. You’ll need loops and conditionals working together — a for loop to visit each room, and an if inside to decide what awaits.

The remainder operator % is handy here: n % 2 == 0 is true when n is even.

if step%2 == 0 {
 fmt.Println("even step")
}

Your Quest

Loop from room 1 to rooms (5). For each room, print Room N: trap! if the room number is even, otherwise Room N: safe. (using the real number in place of N).

Quest: The Inventory

Sat, 06 Jun 2026 11:00:00 +0000

You’ve returned from the dungeon with a pile of loot. Time to tally it up — a classic job for a slice (the loot) and a map (the running counts).

Ranging over a slice gives you each item; incrementing a map key counts them:

for _, item := range loot {
 counts[item]++
}

Incrementing a missing key just starts it from its zero value (0), so you don’t need to initialise each entry.

Quest: The Locked Chest

Sat, 06 Jun 2026 11:00:00 +0000

A locked chest sits before you. This quest brings together Module 6: an interface (Lock) implemented by a type (Chest), and the error it returns when the wrong key is used.

Your Quest

Call l.Open("silver"). If it returns an error, print it; otherwise print The chest opens!. Since the chest only opens for "gold", you should see:

the chest stays shut

Hint

err := l.Open("silver"), then if err != nil { fmt.Println(err) } else { fmt.Println("The chest opens!") }.

Quest: The Spell Loop

Sat, 06 Jun 2026 11:00:00 +0000

A barrage of blows is incoming, adventurer. This quest brings together the tools of Module 4: a variadic parameter for the unknown number of hits, a loop to apply them, and multiple return values to report the outcome.

Your Quest

Complete applyDamage: subtract every value in hits from health, then return the remaining health and a boolean for whether it’s still above 0.

With applyDamage(100, 30, 40, 20) the hits total 90, so:

Quest: The War Party

Sat, 06 Jun 2026 11:00:00 +0000

The war party charges, each member striking at once. This final concurrency quest brings it all together: a goroutine per attacker, a channel to collect their damage, and a WaitGroup to know when every blow has landed before we tally up.

Your Quest

Inside the loop, launch a goroutine for each d that sends d into the results channel and then calls wg.Done(). Pass d in as an argument so each goroutine gets its own value.

Select & sync

Sat, 06 Jun 2026 11:00:00 +0000

When you’re juggling several channels, select waits on all of them at once and runs whichever is ready first:

select {
case msg := <-orders:
 fmt.Println("order:", msg)
case <-quit:
 fmt.Println("standing down")
}

The sync package covers the cases where channels are overkill — sync.WaitGroup (which you’ve met) for waiting, and sync.Mutex (Lock/Unlock) to protect shared state from concurrent writes.

Your Quest

Use a select statement to receive a value from the ready channel and print it. (It’s a buffered channel that already holds "go!", so the receive is ready immediately.)

Structs

Sat, 06 Jun 2026 11:00:00 +0000

So far our heroes have been scattered across separate variables. A struct lets you bundle related fields into a single custom type:

type Monster struct {
 Name string
 HP int
}

You create a value with a struct literal and reach fields with a dot:

goblin := Monster{Name: "Goblin", HP: 30}
fmt.Println(goblin.Name) // Goblin
goblin.HP = 25 // fields are mutable

Your Quest

Create a Hero value named "Elara" at level 5, then print its Name and Level.

Switch Statements

Sat, 06 Jun 2026 11:00:00 +0000

When you have one value and many possible branches, a chain of else if gets noisy. Go’s switch is cleaner:

switch weather {
case "sunny":
 fmt.Println("A fine day to adventure.")
case "stormy":
 fmt.Println("Best stay at the inn.")
default:
 fmt.Println("Weather unknown.")
}

Unlike many languages, Go does not fall through to the next case automatically — each case stops on its own, so you rarely need break.

Your Quest

Switch on class: print Casts a fireball! for "Mage", Swings a sword! for "Warrior", and Waits. for anything else.

Types & Long-hand Variables

Sat, 06 Jun 2026 11:00:00 +0000

The := operator is handy, but sometimes you want to be explicit about a variable’s type. The long-hand form uses the var keyword followed by a name and a type:

var heroName string = "Aragorn"
var level int = 5
var alive bool = true
var damage float64 = 12.5

Go’s basic types include string, int, bool, and float64. If you declare a variable without a value, it takes that type’s zero value (0, "", or false).

Your Quest

Declare a bool variable named isReady set to true using the long-hand var form.

Variables

Sat, 06 Jun 2026 11:00:00 +0000

Adventurers need somewhere to keep their gold, health, and gear. In Go, that somewhere is a variable. The quickest way to make one is the short declaration operator :=, which both declares the variable and infers its type from the value.

gold := 100 // an int
name := "Elara" // a string

Your Quest

The program already declares baseHealth. Declare a second variable bonusHealth set to 50 so the program prints the total.

Expected output:

Variadic Functions & Closures

Sat, 06 Jun 2026 11:00:00 +0000

Sometimes you don’t know how many arguments you’ll get — a party might have one hero or six. A variadic function accepts any number of them using ...:

func shout(words ...string) {
 for _, w := range words {
 fmt.Println(w)
 }
}
shout("for", "the", "realm")

Inside the function, the variadic parameter is just a slice.

Functions are also values in Go, and a closure is a function that captures variables from around it — handy for counters and generators:

Structured Logging in Go with log/slog - The Complete Guide

Wed, 03 Jun 2026 12:00:00 +0000

In this tutorial we are going to take a thorough look at log/slog — the structured logging package that landed in the standard library in Go 1.21. By the end you’ll know how to configure handlers, set log levels, attach structured attributes, carry loggers through context.Context, write your own handlers, and redact sensitive fields.

We’ll also make the case for why slog has become the default choice for new Go projects, and why it makes third-party loggers like logrus, zap and zerolog hard to justify reaching for anymore.

An Introduction to Go Closures - Tutorial

Tue, 02 Jun 2026 12:00:00 +0000

In this tutorial, we are going to look at closures in Go. We’ll cover the theory behind them, then see how you can use them in your own Go applications.

Closures - The Theory

So, let’s dive into the theory.

We can create and use closures in any programming language that supports functions as first-class objects. Go happens to be one such language, otherwise this article would be pointless.

Makefiles for Go Developers

Fri, 29 May 2026 12:00:00 +0000

In this tutorial we are going to look at how you can use Makefiles to automate the most common tasks in a Go project — building, running, and cross-compiling your application — all from a single make command. By the end you’ll have a working Makefile you can drop into any Go project and extend from there.

What are Makefiles?

Makefiles are an automation tool built around the make command-line utility. You define named targets, each containing a shell script to run, and then invoke them with make <target>. They’re not Go-specific — you’ll find them in C, Python, and Rust projects too — but they’re particularly common in the Go ecosystem because Go projects often need a short sequence of commands (format, vet, build, test) chained together before a binary is ready.

Getting Started with the Claude API in Go

Wed, 27 May 2026 12:00:00 +0000

In this tutorial, we’re going to walk through how to use Anthropic’s Claude API in Go using the official SDK — no Python, no boilerplate frameworks. You’ll learn how to set up the client, send your first message to Claude, and build a proper multi-turn conversation that maintains context across exchanges. These two patterns are the foundation for any AI-powered Go tool you want to build.

If you prefer video, I’ve covered this exact material on YouTube:

Checking if a File or Directory Exists in Go