This week we’re sharing the most popular episode of Go Time from last year — Go Time #196. We believe this episode was the most popular because it’s all about building actually maintainable software and what goes into that. Kris Brandow is joined by Johnny Boursiquot, Ian Lopshire, and Sam Boyer. There’s lots of hot takes, disagreements, and unpopular opinions.

This is part two of a three part mini-series led by Kris on maintenance. Make sure you check out Go Time #195 and Go Time #202 to continue the series.

We’re trying something new this week: discussing the news! Natalie, Kris & Ian weigh in on GopherCon’s move to Chicago, Google DDoSing SourceHut, reflections on Go’s success, and a new/old proposal for anonymous function syntax.

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.

Another entry in the maintenance series! Throughout the series we’ve discussed building versus buying, building actually maintainable software, maintaining ourselves, open source maintenance, legacy code, and most recently Go project structure. In this 7th installment of the series, we continue narrowing our focus by talking about what to do when projects get big and messy.

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.

Has Go caught your interest, but you just haven’t had the time/opportunity to really dig into it? Are you relatively productive in your current language/ecosystem but wonder if the grass truly is greener on Go’s side of the fence? If so, this episode’s for you!

In this episode we will discuss what it’s like to work with legacy code. How you work with it, how to avoid issues arising due to it, as well as when a greenfield rewrite is the best path forward. Hosted by Angelica Hill, joined by some wonderful guests: Dominic St-Pierre, Jeff Hernandez, Misha Avrekh, and Jon Sabados.

Here’s a little bonus episode before we get back to your regularly scheduled Go Time. We’re calling it the funny bits. It’s a compilation of times we cracked up making the show for y’all. If you dig it, holler at Jerod. If you don’t, email Mat Ryer.

Open Source and other source available projects have been a huge driver of progress in our industry, but building and maintaining an open source project is about a lot more than just writing the initial code and putting together a good README. On this episode of the maintenance mini-series, we’ll be discussing open source and the maintenance required to keep it going.

Each year a group of user researchers and the Go team get together and create a survey for the Go community. The results of the survey are analyzed and turned into a report made available to everyone in the Go community. In this episode we sit down with Alice Merrick and Todd Kulesza to discuss the survey, how it’s made, and some of the interesting results from this year’s survey.

With the constant demands of work and life we often don’t take much time to ensure that we’re maintaining ourselves. In this third episode of the maintenance series, Kris is joined by co-host Natalie, along with Ian Lopshire to discuss the ways in which we can maintain ourselves in this busy and chaotic world.

We’re celebrating our 200th episode with a crazy game of Gophers Say! Mat Ryer hosts two epic teams including Go Time OGs Carlisia, Erik, and Brian!

Ever wonder how new features get added to the go command? Or where tools like gopls come from? Well, there’s an open team that handles just those things.

Just like the programming language itself, many of the tools that Go engineers use everyday are discussed and developed in the open. In this episode we’ll talk about this team, how it started, where it’s going, and how you can get involved.

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

To build or to buy, that’s a constant question we ask ourselves as software engineers. In this episode we dig into the nuance of these options and the space between them with an eye toward both the building of software and its eventual maintenance.

Mat Ryer and Jerod Santo sit down to review and discuss the MOST and LEAST unpopular “unpopular opinions” since we started keeping track of such things. Also Generics.

What is a Product Manager, and do Engineers need them? In this episode, we will be discussing what a Product Manager does, what makes a good Product Manager, and debating if engineering teams truly need them, with some tech companies going without them. We are joined by Gaëlle Sharma, Senior Technical Product Manager, at the New York Times, leading the Identity group.

Go modules brought about quite a few changes to the Go ecosystem. One of those changes is semantic import versioning (SIV), which has a fairly pronounced effect on how libraries are identified. In this episode we are joined by Tim Heckman and Peter Bourgon to discuss some of the downsides to these changes and how it has lead to what a subset of the Go community refers to as the “v2+ problem.”

In this episode we talk with Daniel and Steve about their experience with event-driven systems and shed some light on what they are and who they might be for. We explore topics like the complexity of setting up an event-driven system, the need to embrace eventual consistency, useful tools for building event-driven systems, and more.

The internet wouldn’t exist as we know it if it weren’t for TCP and UDP, yet many developers don’t quite understand the technology powering the web. In this episode we talk with Adam Woodbeck, author of Network Programming with Go, to learn about TCP and UDP; what they are, how they work, and how one can experiment with tools like Wireshark and Go to learn more.