Building Applications with Go

I've built systems handling billions of requests using Go for growth-stage companies in the past. Go is a fantastic language for building scalable and maintainable services in growing engineering teams, it's easy to read, and it provides a ton of useful concurrency primitives. Here are some of the best practices and solutions I've encountered along the way.

Restoring Go Errors in gRPC Services

In my last post, I talked about the benefits of using interfaces in Go. In short, interfaces are a powerful tool to specify the behavior of objects. However, Go interfaces lack a mechanism to specify a predefined set of errors that can be returned to narrow the definition, such as using a throws keyword like in Swift or Java. An error returned by an interface could be any error. This is especially interesting when one implementation involves a network roundtrip that could introduce different errors than a location implementation....Systems Architecture, Golang

Harnessing the Power of Go Interfaces for Decoupling and Scaling at Inngest

Interfaces hide implementation details by specifying the capabilities or behavior of an object. This concept has appeared in different programming languages over time, using different terms like \*traits\* or protocols....Systems Architecture, Golang

Building a DNS message parser in Go

The internet has grown from a couple of research lab sites to a vibrant ecosystem of content and services. Without the ability to resolve human-readable names to machine identifiers, however, it’d be impossible to find anything in the ever-growing web of interconnected systems....Golang, Systems Architecture

Go Embeds and JSON

Even though there’s no way around handling JSON in web services nowadays, the developer experience between different programming languages varies significantly. I had the joy of fiddling around with Go’s particular implementation a while ago, which motivated me to do a follow-up post on embedding types in Go....Golang

Important Rules of Embedding Types in Go

While Go doesn’t come with the typical language concepts for inheritance-based type hierarchies‚ it provides a powerful concept to reuse parts from other interfaces and structs, using embedding....Golang

Common Pitfalls in Go Application Development

While developing production services in Go over the past year, I've noticed a couple of errors sneak in repeatedly, caused by the same set of pitfalls given by the Go language and ecosystem. Fixing the aforementioned issues was strikingly simple in most of the cases, but debugging tended to be a painful journey leading up to the same culprit more than once....Golang

The Weirdest Error I Ever Debugged

When you work on a software project of any kind, you'll come across situations where you spend hours of debugging time, picking everything apart to find why something just doesn't work. In most cases, you'll get down to the source relatively quickly, at least you might find indicators as to where you might need to look next....Golang

Building Go Test Suites using Testify

While testing itself is a first-class citizen in Go, features like nested tests and setup and teardown mechanisms are not. Luckily, libraries like testify add capabilities for writing powerful assertions, mocking, and organizing tests in suites....Golang, Testing, Integration Testing

Verifying Asymmetrically-Signed JWTs in Go

JSON Web Tokens are a popular way of managing authorization and authentication policies for web applications. Sending around a base64-encoded token that can be verified by every service using it, enables uncomplicated (and stateless) application design compared to other mechanisms....Golang, Json Web Tokens (JWT)

Building Composable Go Applications With Interfaces

In my last post, I wrote about the benefits of designing your applications in a composable way by the means of being able to substitute commonly-used functions based on randomness with deterministic alternatives for stress-free testing. This is by far not the only use case for providing interchangeable logic to parts of your system which don't care about the implementation of said features, as long as the result is valid....Golang, Systems Architecture

Conquering Randomness with Composable Go Application Design

Over the last few months, I got to write a lot of Go code. In addition to all this code, I wrote a lot of tests. Testing in Go is an absolute breeze, mainly because it's built into the language core and is accompanied by fantastic tooling. If you write a lot of tests, you start to observe that randomness becomes your enemy: IDs will always look different, they aren't predictable....Golang, Systems Architecture

Testing Web Applications in Go

We all know that testing is one of the most important tasks when writing our software. Creating unit tests of pure functions is straightforward. You set up your test function, assert that the response matches your expectations and call it a day. Testing your request handlers sounds more difficult, or does it?...Golang, Testing

Recovering HTTP Handlers In Go

Sometimes, things go bad. There's no denying that worst cases will occur and request execution might have to be terminated completely. When it comes to your own code, you'll probably know when errors are returned and what this means for your request lifecycle, whether it should be continued or return an error message instead. This is the easy case, you'll get the error and can decide what to do with it. Your handler func could look like the following (very simplified) example:...Golang, Systems Architecture

Improving Static Assertions with Snapshot Tests in Go

Testing your Go code in all ways imaginable is really straightforward using the testing package included in the standard library. Very often you'll write assertions to check if the outcome of your project's API (your exported methods and functionalities) equals your expectations, for example, if a generated data structure matches a common spec you're trying to support....Golang, Testing

Scaling Network Concurrency in Go

I recently built a job that retrieves a list of files, processes, and batches those to then re-upload said files to a different location. Quickly after deploying the initial version, when running the job on larger targets, it became evident that something was off, essentially making the service unusable....Golang, Networking, Systems Architecture

Understanding Go's context package

The context package and feature is a core part of how most Go applications are built today. Very often, you want to define a timeout, deadline or have the ability to cancel a certain operation and all its invoked functionality from running respectively. When building applications for the web, all of those decisions are usually made inside of a request-response cycle....Golang

Parallelized Batch Processing in Go

Imagine you're building a worker service that will receive a huge list of file metadata to be processed, one by one. Each object represents a file, which you want to upload from one source to the other. Because it won't be a problem, you decide that it makes sense to process subsets of the original array in parallel, decreasing the overall execution time and enabling de-duplication, for example checking if a file was already handled when it's added more than one time and ignoring it in this case....Golang, Concurrency, Synchronization, Systems Architecture

Handling Concurrent Go Workflows

Wrapping your head around writing non-blocking, concurrent code can be hard at times, especially when you can't estimate the cost of building your application one way or the other. Using Go's broad spectrum of possibilities to execute synchronously-written and blocking code concurrently with little additional effort shows one of the reasons for Go's massive adoption in highly-available production environments and distributed systems....Golang, Concurrency

Choosing the Right Go Web Framework

Admittedly, there's a lot of libraries and frameworks to build modern web services in Go, suitable for pretty much every situation you'll ever run into. But sometimes you might just want to use a minimal foundation to build upon, not the full-blown system with all the numerous extensions and features you probably won't ever use for your project. Looking at the ecosystem, I've reduced the number of libraries to compare down to four key players: gin, echo, chi and finally mux....Golang