Event-driven systems may not be the go-to solution for everyone because of the challenges they can add. While the system reacting to events published in other parts of the system seem elegant, some of the complexities they bring can be challenging. However, they do offer durability, autonomy & flexibility.

In this episode, we’ll define event-driven architecture, discuss the problems it solves, challenges it poses & potential solutions.

You had questions, the Go Team had answers! Topics covered include generics (of course), governance (of course), Go 2, text editors, GitHub Copilot, garbage collection, and more.

Building software is difficult and time consuming, but the maintenance of software is where we spend the majority of our time. In this episode, Ian and sam join Johnny and Kris to discuss how to build actually maintainable software, the features of Go that make it good for writing maintainable software, and different ways that we might define the term “maintenance”.

Natalie and Johnny are joined by the co-founders of APIToolkit for a deep-dive on the topic. We discuss building them, maintaining them, how can we all be better users, and much more along the way.

Carmen and Jon talk with Rob Pike and Robert Griesemer (the creators of Go) about its origins, growth, influence, and future. This an epic episode that dives deep into the history and details of the how’s and why’s of Go, and the choices they’ve made along the way in creating this awesome programing language.

So, do we like generics or not? Some people feared they’d be the end of the language. Others were very hopeful, and had clear use cases, and were thrilled about the feature coming to the language. It was also often touted as the reason a lot of people didn’t adopt Go. So what do we think now? Mat and Kris are joined by Roger Peppe and Bryan Boreham to discuss the state of Generics in Go.

What does it take to master a programming language like Go? Joining us is the author of Mastering Go to help us answer that very question and to discuss the third edition of the book.

We often have code that’s similar between projects and we find ourselves copying that code around. In this episode we discuss what to do with this common code, how to organize it, and what code qualifies as this common code.

How do beginners learn Go? This episode is meant to engage both non-Go users that listen to sister podcasts here on Changelog, or any Go-curious programmers out there, as well as encourage those that have started to learn Go and want to level up beyond the basics. On this episode we’re aiming to answer questions about how to learn Go, identify resources that are available, and where you can go to continue your learning journey.

In this episode, we’re joined by Kelsey Hightower to discuss the evolution of cloud infrastructure management, the role Kubernetes and its API play in it, and how we, as developers and operators, should be adapting to these changes.

Natalie and Mat explore hacking in Go from the eyes of 2 security researchers. Joakim Kennedy and JAGS have both used Go for hacking: writing malware, hardware hacking, reverse engineering Go code, and more.

A quick look at the history of building web apps, followed by a discussion of htmx and how it compares to both modern and traditional ways of building.

On this episode, Michael Matloob and Daniel Martí pinky promise not to talk about Go 1.18’s two big features (fuzzing and generics). Instead, we’re focusing in on the other cool stuff that’s new!

Natalie sits down with Go book authors Bill Kennedy & Sau Sheong Chang to discuss the ins and outs of writing (and reading) books about Go!

Mark Sandstrom and Ben Kraft join Jon and Mat to talk about GraphQL. What exactly is it this query language everyone has been talking about? How does it work? What Go libraries are out there, and where should you get started?

Tiago Mendes joins Mat, Jon, and Johnny to discuss eventual consistency and strategies for changing data at scale.

Bryan Boreham (Grafana Labs) and Jordan Lewis (Cockroach Labs) join Mat and Jon to talk about memory management in Go. We learn about the heap, the stack, and the garbage collector. There are also some absolute gems of wisdom scattered throughout this episode, don’t miss it.

On a previous episode of Go Time we discussed binary bloat, and how the Go protocol buffer implementation is a big offender. In this episode we dive into the history of protocol buffers and gRPC, then we discuss how the protocol and the implementation can vary and lead to things like binary bloat.

The panel are joined by Teiva Harsanyi, author of 100 Go Mistakes, to talk about how best to make mistakes when writing Go.

Matthew Boyle, the author of Domain-Driven Design with Golang, sits down with Jon & Mat to talk about (you guessed it!) DDD with Go.

Let’s talk about the concept of immutable databases, the problems they target, and why you’d want to build one in Go.

Ed Welch joins Mat and Jon to discuss logging. They explore the different options for logging in Go, and discuss what data is worth including. Everything from log levels, formats, non-structured vs structured logs, along with common gotchas and good practices when dealing with logs at scale.

We’ve talked several times about getting started with Go. But Go is already 12 years old! Let’s talk about how it all started, and hear about it from the people who were there from the beginning.

We’re talking OpenAPI this week! Kris & Johnny are joined by Jamie Tanna, one of the maintainers of oapi-codegen, to discuss OpenAPI, API design philosophies, versioning, and open source maintenance and sustainability. In addition to the usual laughs and unpopular opinions, this week’s episode includes a Changelog++ section that you don’t want to miss.

During a conversation in the #gotime channel of Gopher Slack, Jerod mentioned that some people paint with a blank canvas while others paint by numbers. In this 8th episode of the maintenance series, we’re talking about maintaining our knowledge. With Jerod’s analogy and a little help from a Leslie Lamport interview, our panel discusses the myth of incremental progress.

Mat invites Bartłomiej Płotka, Kemal Akkoyun & Christian Simon to discuss how to make Go code more efficient through modern observability practices.

eBPF (7 years old) is a sandbox that can run code inside the linux kernel. It started as a technology to build firewalls, and has evolved over time to include a range of new features.

The panel discuss the origins of eBPF and how it works, as well as dig into some real-world use cases. While eBPF programs themselves aren’t written in Go (more like C), we will hear about how you can communicate with eBPF programs from your Go code.

Alexey Palazhchenko joins Natalie to discuss the implications of GitHub’s Copilot on code generation. Go’s design lends itself nicely to computer generated authoring: thanks to go fmt, there’s already only one Go style. This means AI-generated code will be consistent and seamless. Its focus on simplicity & readability make it tailor made for this new approach to software creation. Where might this take us?

MLOps is an increasingly popular topic that is no longer just a subset of DevOps. Go is a great choice for infrastructure. What role does Go play in MLOps?

This is THE podcast for diverse discussions from around the Go community.

Go Time’s panel hosts special guests like Kelsey Hightower… (clip from episode #114)

picks the brains of the Go team at Google… (clip from episode #100)

shares their expertise from years in the industry (clip from episode #102)

and has an absolute laugh riot along the way… (clip from episode #110)

It is Go Time! Please listen to a recent episode that interests you and subscribe today. We’d love to have you with us.