What makes a good, bad, and truly great workshop? How do you put together a Go workshop that works, and how do you get the most out of workshops you attend?

The 3 Musketeers return! Filippo Valsorda, Roland Shoemaker & Nicola Murino continue their deep-dive conversation with Natalie about Go’s crypto libraries.

Also listen to Part 1 and Part 2!

In this episode, Ben Burkert & Chris Stolt join Johhny to explore the ups & downs of trying to get secure local development environments set up, why it’s hard & what you can do about it.

Natalie is joined by Carlos Becker (a Brazil-based software developer who maintains GoReleaser and other OSS software) to discuss how GOOS and GOARCH spark joy.

Felix Geisendörfer & Michael Knyszek join Natalie to discuss Go execution traces: why they’re awesome, common use cases, how they’ve gotten better of late & more.

In this episode Matt, Bill & Jon discuss various debugging techniques for use in both production and development. Bill explains why he doesn’t like his developers to use the debugger and how he prefers to only use techniques available in production. Matt expresses a few counterpoints based on his different experiences, and then the group goes over some techniques for debugging in production.

In this episode we answer any/all questions from a new Go developer. Features, best practices, quirks of the language… it’s all on the table for discussion.

Jumping into a codebase you’re unfamiliar with can be challenging. Are there better & worse ways to go about it? In this episode, Ian gathers a panel (Johnny, Kris & Jon) to discuss the ins & outs of familiarizing yourself with an existing codebase.

We’re all thinking about it and wondering if our job is safe from AI. Maybe. Maybe not. In this episode Johnny Boursiquot is joined some industry veterans who have been through multiple innovation cycles to share their insights and advice on this subject.

Angelica is joined by the wonderful Anthony Starks to discuss creative coding to create art & visualizations with Go. Anthony is an independent developer/designer interested in data visualization, generative art, building tools & combining art + code.

In the first of a multi-part series, Ian & Johnny are joined by Miriah Peterson & Bryan Boreham to peel back the first layer of the things that matter when it comes to the performance of your Go programs.

Our award winning worthy survey game show is back, this time Mat Ryer hosts it live on stage at GopherCon EU Athens 2024! Join in & play along as we see which team can better guess what these GopherCon gophers had to say!

Our “what’s new in Go” correspondent, Carlana Johnson, joins Johnny & Ian to discuss what’s new with the latest iteration of Go in version 1.22.

Angelica is joined by Neil S Primmer & Benji Vesterby to share their experience organizing “Capture the Flag” at GopherCon 2023. CTF events involve teams vying for supremacy as they strive to gather digital flags (presented as strings) and successfully submit them to the competition organizers. In essence, it’s a thrilling “scavenger hunt for nerds.” Join us as we unravel the intricacies and excitement of this unique gaming experience!

Over the past 8 years, Go Time has published 300 episodes! In this episode, the panel discusses which ones they loved the most, some current stuff that’s in the works, what struggles the podcast has had & what we’re planning for the future.

In this episode Matt joins Kris & Jon to discuss Kafka. During their discussion they cover topics like what problems Kafka helps solve, when a company should start considering Kafka, how throwing tech like Kafka at a problem won’t fix everything if there are underlying issues, complexities of using Kafka, managing payload schemas, and more.

Filippo Valsorda & Roland Shoemaker from the Go Team return & bring Nicola Murino with them to continue catching us up on what’s new in Go’s crypto libraries.

This is everything we didn’t cover + deep dives from Part 1!

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.

Rob Pike says, “Simplicity is the art of hiding complexity.” If that’s true, what is simplicity in the context of writing software in Go? Is it even something we should strive for? Can software be too simple? Ian & Kris discuss with return guest sam boyer.

Filippo Valsorda & Roland Shoemaker from the Go Team sit down with Natalie to catch us up on what’s new in Go’s crypto libraries. No, not that crypto… good ol’ cryptography! Don’t miss Part 2!

John Gregory’s GopherCon talk “7 Deadly Gopher Sins” is the ostensible basis of this spooky Go Time episode, but with Mat Ryer at the helm… the only thing to expect is the unexpected. And failed jokes. Expect lots of failed jokes.

The 10th GopherCon took place the last week of September and it was a blast. In this episode, we’re talking about our experiences at the conference from several different viewpoints. Angelica as a conference organizer, Johnny as an emcee and workshop instructor, Kaylyn as a speaker, and Kris as a regular attendee.

Michael Quiqley from NetFoundry joins Natalie to discuss Zero Trust concepts, why they are important for secure systems & how to implement them in Go.

Go’s known for it’s fantastic standard library, but there are some places where the libraries can be challenging to use. The html/template package is one of those places. So what alternatives do we have? On today’s episode we’re talking about Templ, an HTML templating language for Go that has great developer tooling. Co-hosts Kris Brandow and Jon Calhoun are joined by Adrian Hesketh, the creator of Templ, and Joe Davidson, one of the maintainers on the project.

V Körbes returns to talk prototyping with Natalie, Johnny & Kris. Is Go good for prototyping? What makes a language prototypable, anyway? How does space radiation fit in to all this? Tune in and ride along to find out!