What’s going on here?

This newsletter is for Go hackers looking for:

• how-to guides for implementing development workflows,
• some background on why those workflows work and when they fit,
• explanations of high-level design patterns – especially in web applications,
• and how-to guides for implementing those patterns.

What’s a quick and effective way to launch a new Go web project with tests and CI enabled from the start?

What should you put into a Makefile? Should you be using a Makefile for your Go project? (Yes, you should.)

How do you integrate Gorm into a Gin web app? Are ORMs really useful or do they really just cause problems? If you don’t use an ORM what’s a good way to just use SQL directly without having a bunch of boilerplate?

What’s the right way to split an app into smaller subpackages? (For a small self-contained app: you probably don’t need to, and subpackages are just going to get in the way.)

How do you write tests for route handlers?

Universal Glue … wat?

A lot of my thinking on how to build software comes from a Unix-based worldview where “everything is a file” and line-oriented pipes are the universal way to pass data around.

In a network-centric world that worldview is less useful. The new paradigm is more like “everything is an HTTP endpoint” and JSON blobs are the universal way to pass data around.

Both approaches still have value in different contexts. If we’re operating strictly in a local context, then files and plain text are still very useful. In a network context, then HTTP+JSON makes a good default choice since it’s the lowest common denominator.

Either way, our job as developers is to glue together the components at hand to produce something valuable.

“Universal Glue” is the label I’ve attached to the idea that we can build software with Go to do that gluing, either with files+text or HTTP+JSON. (“Why Go?” is a question for another day.)

What You Can Expect

New articles go out on Tuesdays and Fridays. The Tuesday issue will have less code and more Big Ideas. Fridays will contain a get-your-hands-dirty how-to guide.

The initial series of articles will walk through some of the interesting parts of a project I’m building for personal use — a web app built using gin and sqlite. Articles will cover some of the tools I use, some of my development workflow, and not one but TWO approaches to local deployment (one of them is fairly brain-dead but it actually works great a lot of the time).

Later I plan to look at CLI-based apps, especially as glue to other services or apps.

I think a lot about how to build software — both in terms of development workflows and “ergonomics” (especially at the personal level) and the actual mechanics of converting Go or whatever language to executable bits — so a good chunk of the Big Ideas will be about how to improve the process and/or better approaches to generating executable bits. (Both of those kinds of ideas are often intertwined.)