Golang

Systems Architecture

Enhancing Scalability and Reducing Latency Without Missing a Beat

At Inngest, we serve hundreds of millions of events per day. Each event can trigger a function run comprising multiple steps. Users can return blobs and other data from these steps, necessitating incredibly fast reads and writes to our data store to keep latency as low as possible. Function runs

Systems Architecture

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

Systems Architecture

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. The same rules apply in Go, take the classic example of io.Reader: type Reader interface { Read(p []byte) (n

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. In November 1987, RFC 1034 and

Golang

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. Using the example from Effective Go, for interfaces, embedding allows borrowing pieces of an implementation by embedding types type Reader interface

Systems Architecture

Communicating between services with gRPC

Setting up the communication layer between services can be a cumbersome task, even if they’re written in the same language, built on top of the same framework, and running on the same infrastructure. Every minute spent debugging weird connection issues, malformed payloads, and other parts that occasionally break could

Golang

Solving the unexecutable executable

Sometimes when building software, I run into problems that are extremely weird to grasp, and usually connected to something much more simple that wasn't immediately obvious. I think we often deal with small frustrations and once we have a fix, we move on, ignoring the educational value: Let

Golang

Communicating between Java and Go using gRPC

Sometimes you're working between two systems, running in different processes, based on different programming languages. If you want to get instructions or data across those two, you'll need a layer that handles communication. Naturally, you'd rather spend your time building the actual thing rather

Notion API

Sending Contact Form Submissions to Notion

With Notion launching their public API beta a couple of hours ago, I wanted to try out to pipe my newly-added contact form submissions to a Notion database. Database pages in notion are made up of a combination of page properties and content. Properties such as the page name (title)

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

Amazon Web Services (AWS)

Forwarding Incoming Mails with AWS Lambda and SES

We all have that one domain we want to receive incoming mails on. Whether it's a side project or even the personal domain, being able to forward incoming emails back to our personal inbox can be extremely useful. In most cases, your domain registrar probably offers to forward

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

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. import ( "testing" "github.com/stretchr/testify/suite" ) // We'll

Golang

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. In many cases, JWT-based flows will be built around asymmetric

Golang

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

Golang

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

Golang

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

Golang

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

PostgreSQL

Real-Time Postgres Change-Streaming With lode

I'm thrilled to announce a new project I've been putting hours into the last couple of days! Building data-driven products often means that you want to be able to react to changes as soon as they come in. This means, that you'll expect ways

Golang

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

Golang

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. The

Golang

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

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

Golang

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

Golang

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

GraphQL

The State of GraphQL × Go

I initially planned on writing this post to be about benchmarking and comparing implementations of GraphQL libraries and servers in Go vs. the popular JavaScript & Node.js alternatives like Apollo Server, etc. After delving into the Go ecosystem however, I've found myself switching between a couple of