-
Did you know you can run your own Base node with Go?
Run your own Base L2 node using Go. Learn how base/node works and why Ethereum scaling chose Go.
-
Gin: The Go framework that makes APIs feel effortless
Learn why Gin is the most popular Go web framework and how to build fast, clean APIs with it.
-
The CLI tool every developer should know: fzf
fzf is a blazing fast fuzzy finder written in Go. Here's why it should be in your toolkit.
-
The only Go bookmark you actually need
Awesome Go is the ultimate curated list of Go libraries and tools. Here's how to use it effectively.
-
The fuzzy finder that changed how I use the terminal
fzf is a blazing-fast fuzzy finder written in Go. Here's how to use it.
-
Why Caddy might be the fastest Go web server you can run
Caddy delivers serious performance with automatic HTTPS and zero config. Here's how it works under the hood.
-
Did you know Docker is actually built on Moby?
Moby is the open-source project behind Docker containers. Here's what Go developers should know about it.
-
Why frp is the reverse proxy you should know about
Expose local servers through NAT and firewalls with frp - a blazing fast Go-powered reverse proxy.
-
Syncthing: The P2P file sync tool written in Go
Syncthing syncs files between devices without a cloud. It's open source, peer-to-peer, and built entirely in Go.
-
Hugo: The Static Site Generator That Powers This Blog
Hugo is the world's fastest static site generator. Here's why it's built in Go and how to test your Hugo themes.
-
Exploring Kubernetes: A Go Library Worth Knowing
Discover how Kubernetes uses Go and how you can interact with it programmatically using the client-go library.
-
Exploring the Go Repository: Understanding How Go Is Built
Dive into the official Go repository to understand how the language is built, contribute, and learn from world-class code.
-
The Best Way to Learn Go? Read the Source Code
Discover the Go programming language source code, its architecture, and what makes it worth exploring.
-
Exploring Ollama: Running LLMs Locally with Go
Learn how to use Ollama to run DeepSeek, Gemma 3, Llama 3, and other LLMs locally with Go's official client library.
-
Mastering Enums in Go: Best Practices and Implementation Patterns
Go doesn't have traditional enums, but we can implement powerful enum-like patterns. Learn how to create robust, type-safe enumerations in Go.
-
Understanding SBOM in Go: Why It Matters and How to Generate One
A deep dive into Software Bill of Materials (SBOM), its importance in Go projects, and how to generate one using CycloneDX.
-
Building Model Context Protocol Servers in Go: Enhancing AI Tools with Your Data
Learn how to build MCP servers in Go to connect your private data sources to AI tools like Cursor for more powerful coding experiences.
-
Building Native Desktop Apps with Go and Wails: A Quick Dive
Did you know you can build native desktop applications with Go? See how here!
-
Filter a slice in Golang
Slices are a cornerstone of Go programming, offering a flexible way to work with sequences of data. One common task is filtering a slice—selecting elements that meet specific criteria. Let's see how to do that
-
The Go Scheduler: How I Learned to Love Concurrency in 2025
If you’ve wondered how Go manages thousands of goroutines while other languages struggle with threads, this post is for you.
-
Best Golang books available on Amazon
Looking for the best Golang resources on Amazon? Discover the top-rated books, learn why Go is so popular, and find exactly what you need to master this powerful programming language.
-
A Simple Guide to Switch Statements in Go
Do you ever get tired of writing multiple `if-else` statements in your Go code? **Golang case** statements (also known as switch statements) can make your logic clearer, faster, and easier to maintain. In this post, I'll walk you through how to use a switch statement in Go to simplify your code.
-
A round up of Go 1.24's performance improvements
Go 1.24 boasts improvements for everyone, without doing anything. Let's see how.
-
Testing Concurrent Code Using the Experimental 'testing/synctest' Package
Concurrent code is notoriously difficult to test. Let's see how the new version of Go helps us here.
-
Introducing weak pointers in Go 1.24
Weak pointers can make certain classes of program much faster. Let's see how.
-
Go 1.24's New Benchmark Function; a better way to benchmark
An in-depth look at Go 1.24's new testing.B.Loop method for writing better benchmarks
-
Maps are faster in Go 1.24
...at least for most use cases. Read on to find out more!
-
omitzero in Go1.24: tips and gotchas!
Go 1.24 is going to make working with JSON much better. Let's see how.
-
Understanding the New JSON Output in ‘go build’ and ‘go test’ Commands in Go 1.24
Because machine-parsable output is always welcome.
-
How to Use the New tool Directive in Go 1.24
managing tools has always been challenging in Go. The Go 1.24 release makes it much simpler. Let's see why.
-
Exploring Generic Type Aliases in Go 1.24
Go 1.24 introduces generic type aliases, enabling you to define type aliases with their own type parameters. This change allows more flexible and maintainable code, especially during refactoring.
-
10 years of functional options and key lessons Learned along the way
Functional options are a powerful Golang pattern that can be used to write small and flexible APIs. Here's some Lessons Andrea learnt the hard way of how and when to use them.
-
Common Goroutine Leaks in Go and How to Avoid Them
Learn to identify, prevent, and fix goroutine leaks in Go applications. Understand common patterns that cause leaks and best practices for writing leak-free concurrent code.
-
Error Handling Best Practices in Go
Learn how to handle errors effectively in Go with best practices, custom error types, error wrapping, and practical patterns for production code.
-
AOC 2024, Day 25: Locks, Keys and Stars!
Let's solve the last day of Advent of Code 2025 and collect all 50 stars!
-
AOC 2024, Day 24: Ripple Carry Adder
Let's solve Advent of Code 2024 Day 24 by fixing a faulty Ripple Carry Adder!
-
AOC 2024, Day 23: Bron–Kerbosch Algorithm
Let's solve Advent of Code 2024 Day 23 with Bron–Kerbosch Algorithm!
-
AOC 2024, Day 22: Maximum Bananas
Let's solve Advent of Code 2024 Day 22!
-
AOC 2024, Day 21: Keypad Madness
Let's solve Advent of Code 2024 Day 21, a very tough puzzle indeed!
-
AOC 2024, Day 20: Manhattan Distance to the Rescue
Let's solve Advent of Code 2024 Day 20 using Manhattan Distance!
-
AOC 2024, Day 19: Designing Towels
Let's solve Advent of Code 2024 Day 19 with recursion!
-
AOC 2024, Day 18: Falling Walls
Let's solve Advent of Code 2024 Day 18 with Dijksta's Algorithm!
-
AOC 2024, Day 17: Implementing a Quine
Let's solve Advent of Code 2024 Day 17 and learn about Quine!
-
AOC 2024, Day 16: Fun with Dijkstra
Let's solve Advent of Code 2024 Day 16 with Dijkstra algorithm!
-
AOC 2024, Day 15: Moving Boxes
Let's solve Advent of Code 2024 Day 15 by moving boxes in a 2D grid!
-
AOC 2024, Day 14: Christmas Tree Hunt
Let's solve Advent of Code 2024 Day 14 and learn about image entropy!
-
AOC 2024, Day 13: Solving Linear Equations
Let's solve Advent of Code 2024 Day 13 with highschool maths!
-
AOC 2024, Day 12: Counting Corners
Let's solve Advent of Code 2024 Day 12 with some polygon math!
-
AOC 2024, Day 11: Memoisation FTW
Let's solve Advent of Code 2024 Day 11 with memoisation!
-
AOC 2024, Day 10: Part 2 easier than part 1?
Let's solve Advent of Code 2024 Day 10!
-
Deploying gRPC Applications Using Sevalla
If you have spent any time in the Javascript ecosystem, you will have found you can often deploy entire apps just by pushing to GitHub. Go is fairly easy to deploy generally, but it is still not quite as simple as that...until now.
-
AOC 2024, Day 9: Bonus Heaps!
Let's solve Advent of Code 2024 Day 9 and then optimise it with heaps!
-
AOC 2024, Day 8: Reading Comprehension
Let's solve Advent of Code 2024 Day 8, but first let's understand the problem correctly!
-
AOC 2024, Day 7: Recursion to the Rescue
Let's solve Advent of Code 2024 Day 7 with recursion!
-
AOC 2024, Day 6: Escaping & Adding Obstacles
Let's find the path for the guard to solve Advent of Code 2024 Day 6!
-
AOC 2024, Day 5: Custom Sort
Let's solve Advent of Code 2024 Day 5 and use Golang's custom sort!
-
AOC 2024, Day 4: Find the X
Let's solve a couple of word puzzles with Advent of Code 2024 Day 4!
-
AOC 2024, Day 3: All About Regex
Let's solve Advent of Code 2024 Day 3 with regex!
-
AOC 2024, Day 2: Slice Internals Reminder
Let's solve Advent of Code 2024 Day 2 and revisit slice internals!
-
AOC 2024, Day 1: Missing abs() for integers
Let's solve Advent of Code 2024 Day 1 and investigate about the missing function to calculate absolute for integers!
-
Mastering String formatting in Go
Formatting strings is a fundamental aspect of programming, and Go provides an easy way to do this via the `fmt` package. Whether you're constructing user-facing messages, logging debug information, or building complex output for APIs, understanding string formatting in Go is crucial.
-
Golang JSON to Struct: A Complete Guide
Learn how to convert JSON to a Go struct effortlessly using Golang tools and Goland features. Includes code examples and tips for rapid development.
-
Converting byte to string in Go
This is fundamental in Go, let's learn how to do it!
-
The Evolution of the Go Programming Language | A Comprehensive Overview
It’s no surprise that Go has become a favorite among developers. Let's learn why!
-
gRPC use cases
Unlocking the Power of High-Performance Communication
-
Explaining Go Interfaces | What They Are and Why They Matter
Interfaces are essential in Go for building testable systems. Let's see why
-
Enhancing gRPC Security | Best Practices for Secure Communication in Microservices
Keeping gRPC services secure is essential. Lets learn how to do that
-
gRPC Load Balancing | The Essential Guide to Scalability and Efficiency
In today’s world of distributed systems, handling large volumes of traffic without a hitch is crucial. Let's see how to do it with gRPC
-
Boosting gRPC Performance | A Practical Guide for High-Throughput Applications
In the world of microservices, distributed systems, and real-time applications, performance can be the deciding factor between a successful system and one that struggles under load.
-
Golang continue: Simplifying Your Loop Logic for Cleaner Code
When it comes to programming, loops are the backbone of repetition, data processing, and efficient workflows. In Go, loops are straightforward, yet powerful.
-
Understanding gRPC Middleware: Enhance Your gRPC Applications
gRPC middleware is essential to keeping your code DRY and secure, lets see how.
-
Getting Started with Go: Write Your First Hello World Program in Go
Writing Hello World is a rite of passage for all programmers. Let's see how to do it in Go!
-
Golang REST API: Everything You Need to Get Started
Creating a REST API in Golang is an enriching experience that combines Go's exceptional performance and simplicity with the principles of RESTful architecture. Let's see why
-
How to Use gRPC Effectively: Best Practices You Should Follow
Efficient communication between services is crucial, especially when building distributed systems. let's learn why!
-
Understanding gRPC vs. HTTP: Key Differences and Use Cases
Selecting the appropriate communication protocol is essential for today’s application development.
-
Why a Golang Certification is Essential for Developers in 2024
Choosing the right programming language can significantly influence a developer's career path
-
Mastering gRPC Error Handling: Best Practices and Key Strategies
As microservices architecture becomes the backbone of modern development, gRPC has emerged as a powerful tool for building high-performance, scalable services. Learn more!
-
Mastering CSV Handling in Go: A Comprehensive Guide to the Golang CSV Reader
When working with data in Go, CSV (Comma-Separated Values) files are among the most popular formats for storing and exchanging information. Go’s rapid development and the new features introduced in recent versions enhance its capabilities for handling various data formats.
-
Golang Type Alias: Simplifying Code and Enhancing Readability
let's learn what a type alias is, and when you might want to use it.
-
The magic of the internal folder
The internal folder in Go is one of the few "magic" features in the Go language where if you use it, you get a bunch of benefit without having to do too much.
-
A Comprehensive Guide to the Flag Package
Reading command line arguments is a common use case for both CLI and API applications - Go makes this very easy to do using just the standard library via the flag package. Let's see how.
-
Reading Files Efficiently in Go
When working with file operations in Go, you should consider reading files line by line. This is especially useful when dealing with large files where loading the entire file into memory would be a bad idea.
-
Securing gRPC Services with JWT Authentication in Go
gRPC provides several mechanisms to enhance the security of your services. In this blog post, we'll explore how to implement authentication in gRPC, focusing on interceptors, metadata, and JWTs (JSON Web Tokens) as the authentication mechanism.
-
Using Go Embed
The go:embed feature simplifies the inclusion of static assets in your Go applications. By embedding files and directories at compile time, you can create more portable and self-contained binaries.
-
Implementing Sets in Golang
A set is a collection of distinct elements that allows you to easily check for membership, add elements, and remove them without worrying about duplicates. While Go doesn’t have a built-in set type like Python or other languages, we can implement one using Go's map type.
-
Interfaces in Go
Interfaces are one of the most powerful features in Go, but they can be confusing at first given their implicit nature.
-
What is Context in Go?
In modern Go applications, managing deadlines, cancellation signals, and request-scoped values across API boundaries and goroutines is a necessity.
-
Working With Time in Golang
Time is one of the most challenging things to work with in any programming language. Go makes it as easy as possible. In this blog we'll teach you everything you need to know about working with time and how to write testable time-based code.
-
How to defer in Golang like a pro
The defer keyword in Go offers a way to ensure that resources are properly released and that certain actions are performed, no matter how a function exits.
-
Why You Should Think Twice Before Using the init Function in Go
The init function in Go is a powerful feature that allows developers to perform initialization tasks before the program starts executing. While it might seem convenient, relying heavily on the init function can lead to code that’s difficult to understand and maintain (and may not work how you want).
-
Let's Map This Out
one of the most powerful and flexible data structures is the map. Whether you’re a experienced developer or new to Go, understanding how to effectively use maps can enhance the efficiency and clarity of your code.
-
A Guide to Golang Generics
In this blog, we’ll take a look at Golang generics, exploring what they are, why they’re useful, and how to implement them in your Go projects.
-
Exploring the Golang Playground: A Go Developer’s Essential Tool
The Golang Playground is an amazing resource for developers working with Go (or Golang). Whether you’re new to Go or an experienced programmer, this browser-based tool allows you to write, share, and run Go code quickly without needing to set up a local development environment.
-
Installing Go: Let's get Started!
Learn how to install Golang (Go) on Windows, macOS, and Linux. This beginner-friendly guide walks you through each step to get started with Golang quickly.
-
What is a switch Statement in Golang?
When programming in Go (or any language for that matter), decision-making is a core part of building applications. Let's see how to do that in Go.
-
How to convert an int to string in Golang
Let's master the basics of Go
-
Understanding Enums in Golang
Enums (short for enumerations) are a useful feature in many programming languages, allowing developers to define a set of named constants that represent unique values.
-
gRPC vs REST
At some point in a growing company, the debate between gRPC and REST becomes a focal point. Both technologies allow communication between distributed systems, yet they differ significantly in their design, functionality, and use cases.
-
Everything You Need to Know About for Loops in Go
For Loops are useful in any language, let's see how they work in Go.
-
Everything you need to know about rubber-duck debugging for Go
As a Go developer, have you ever found yourself stuck on a bug for hours, only to have that “aha” moment when explaining the problem to someone else? This problem isn’t new, and it’s at the heart of what we call Rubber Duck Debugging.
-
Hot Reload for Golang with Go Air
Hot Reload to make developing Go fast!
-
What is gRPC Anyway?
Chances are you have heard people mention gRPC, but what really is it and what's it useful for?
-
Using Status Codes for gPRC
People are often used to REST status codes and have experience using them (even if they are still often abused), but status codes in gRPC work a little bit differently and do not follow the same numeric range as REST status codes. Let's see how they are used!
-
Why gRPC and Go are a Match Made in Heaven
Unless you have been living under a rock, chances are you have heard of gRPC. It's also rare to hear gRPC to be mentioned and not for Go to be.
-
Exploring the New Unique Package in Go 1.23
The Go programming language continues to get better all the time, bringing with it new features and improvements aimed at improving performance and developer productivity.
-
Exploring the New Features in Go 1.23: Iterators and Enhancements to the Slices & Maps Packages
In a previous post we introduced iterators, a new feature in the Go language added in Go 1.23. In this blog post, we will look into the enhancements made to the slices and maps packages. These changes are built on top of iterators, so would not be possible before this release.
-
Iterators in Go 1.23
The Go programming language, renowned for its simplicity and efficiency, has changed quite a bit in the last couple of versions, with generics being one of the bigger changes.
-
Generating A CLI Application with Cobra in Golang
In this blog, we are diving deep into the world of developing advanced command-line applications using the popular CLI framework, Cobra.
-
Writing Idiomatic Go CLIs
In this blog post, we will explore the nuances of structuring CLIs using the flag package in Golang; a topic rarely discussed.
-
Structuring Go Code for CLI Applications
This article is a guide on the first steps of creating a new Go CLI application, beginning with some of the most popular ways to structure code
-
Setting up the Go Debugger in GoLand
The debugger is one of Go's best features. Let's set it up in GoLand this time
-
Setting up the Go Debugger in VSCode
The debugger is one of Go's best features. Let's set it up together
-
Everything You Need to Know about Logging in Go
In this blog post, we'll dive into the world of logging and logging strategies for Go Engineers.
-
Which Environment Variable Libraries do Golang engineers Prefer?
I asked hundreds of Gophers what their favorite way to manage environment variables and configuration was for their Go projects.
-
Which log library should I use in Go?
I asked thousands of Gopher's what log library they used with Golang, and was really surprised by the results!
-
You should probably be using sqlc
Go being type safe is probably one of the biggest benefits that attracted you to the language. However if you ask any Go developer and they will tell you about some pain they experienced writing to SQL Databases.
-
Interface Guards In Go
Here's a cool trick to force a compile-time check that a struct satisfies an interface in Go. We call it an interface guard.
-
Learning Go in 2024; From Beginner to Senior
We all learn differently and at different paces. Finding content that is right for us is challenging. Below is my attempt to curate all the great content I have come across over the years into one place to hopefully help folks advance their Golang journey to the next step.
-
Garbage Collection In Go
For most of us, garbage collection is something we have heard of but never need to pay attention to.However, one of the reasons golang is so efficient and easy to learn is due to its excellent GC.
-
Pair Program More
This is not a Go specific tip and applies to any programming language.
-
How I keep myself Alive using Golang
In this blog I explore how I use an incident management mindset to manage a complex medical condition. I hope you enjoy it!
-
Why is Using the Debugger so Controversial?
It turns out using the debugger is somewhat controversial, who would have thought it?! Let's explore why
-
One Billion Rows Challenge in Golang
The One Billion Row Challenge (1BRC) is intended to be a fun exploration of how far modern Java can be pushed for aggregating one billion rows from a text file. But what happens if you do it in Go?
-
My favorite Go package: errGroup
errGroups are probably my favourite golang package, come and see why!
-
A Little Experiment; Code Review with Jon Calhoun & Matt Boyle
Reviewing code and getting your code reviewed is a great way to learn. We have ran a little experiment and we need your feedback!
-
An overlooked Go Package: Single Flight
Singleflight is a really interesting package that 'provides a duplicate function call suppression mechanism.' It is rarely used but very powerful!
-
Everything you need to know about Go 1.22
Go 1.22 was released on February 7th, 2024. It's a major release with some significant quality-of-life improvements over Go 1.21. Let's go through them!
-
A Brief History of Dependency Management in Go
For those of you newer to Go, it might surprise you to know that go modules was not always part of the language. When Go launched in 2009, it did not have any dependency management solution as Google had no need for one.
-
Context Should Probably be the First Argument of your Go Functions
In golang, the context package plays a big role in controlling the lifecycle of your code, especially when it comes to handling timeouts, cancellation signals, and passing request-scoped values.
-
Getting Started with Tracing & Open-Telemetry Locally Using Go
Whilst working on the Debugging course, I needed to get tracing & open-telemetry working in docker-compose. Here is how you can do it too!
-
gRPC & Go
You have probably heard of gRPC if you haven't used it. It is particularly popular for inter-service communication due to its efficiency, language agnostic nature and support out of the box for things like MTLS. Here's a really simple example of how you can get started with gRPC and hopefully highlights some of the benefits.
-
The Functional Options Pattern in Go
The functional options pattern in Go offers a flexible and readable way to configure your structs without exposing internal fields.
-
How to build a production Docker Image for Go
In this post we'll explore how to make a production ready container image using Go.
-
Ensuring the Go Tool Chain is Verifiable and Reproducible
In Go 1.21, truly reproducible builds were added to Go. Read this blog post to understand why that is important and you should care.
-
Read More Go Code!
People often give the advice that the best way to get better at any programming language is to write more programs. This is true at the start, but as you begin to get more comfortable with the language, the best way to improve is to read lots of other peoples code too.