Go Time: Golang, Software Engineering

By Changelog Media

Listen to a podcast, please open Podcast Republic app. Available on Google Play Store.

Category: Technology

Open in Apple Podcasts

Open RSS feed

Open Website

Rate for this podcast

Subscribers: 46
Reviews: 0

Rafael Moraes
 Nov 23, 2019
It's among my favorites programming podcasts.

 Dec 24, 2018


Your source for diverse discussions from around the Go community. This show records LIVE every Tuesday at 3pm US Eastern. Join the Golang community and chat with us during the show in the #gotimefm channel of Gophers slack. Panelists include Mat Ryer, Jon Calhoun, Natalie Pistunovich, Johnny Boursiquot, Angelica Hill, Kris Brandow, and Ian Lopshire. We discuss cloud infrastructure, distributed systems, microservices, Kubernetes, Docker… oh and also Go! Some people search for GoTime or GoTimeFM and can’t find the show, so now the strings GoTime and GoTimeFM are in our description too.

Episode Date
Hacking with Go: Part 4
Our “Hacking with Go” series continues! This time Natalie & Johnny are joined by Ivan Kwiatkowski & Juan Andrés Guerrero-Saade and the conversation is we’re focused around generics and AI.
Mar 23, 2023
The bits of Go we avoid (and why)
The panel discuss the parts of Go they never use. Do they avoid them because of pain in the past? Were they overused? Did they always end up getting refactoring out? Is there a preferred alternative?
Mar 16, 2023
This will blow your docs off
In a world where most documentation sucks, large language models write better than humans, and people won’t be bothered to type full sentences with actual punctuation. Two men… against all odds… join an award-worthy podcast… hosted by a coin-operated, singing code monkey (?)… to convince the developer world they’re doing it ALL wrong. Grab your code-generator and heat up that cold cup of coffee on your desk. Because this episode of Go Time is about to blow your docs off!
Mar 10, 2023
What's new in Go 1.20
Our “what’s new in Go” correspondent Carl Johnson joins Mat & Johnny to discuss… what’s new in Go 1.20, of course! What’d you expect, an episode about Rust?! That’s preposterous…
Feb 16, 2023
Is htmx the way to Go?
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.
Feb 09, 2023
How to ace that CFP
It’s “Call For Papers” (CFP) season in Go land, so we gathered some seriously experienced conference organizers to help YOUR submission be the best ever.
Feb 02, 2023
Long-term code maintenance
Ole Bulbuk & Sandor Szücs join Natalie to discuss the ins & outs of long-term code maintenance. What does it take to maintain a codebase for a decade or more? How do you plan for that? What about inheriting a codebase for the long term? Oh, and (how) can AI help?
Jan 27, 2023
Who owns our code? Part 2
Tech lawyer Luis Villa returns to Go Time to school us once again on the intellectual property concerns of software creators in this crazy day we live in. This time around, we’re focusing on the implications of Large Language Models, code generation, and crazy stuff like that.
Jan 19, 2023
How Go helped save HealthCare.gov ♻️
Paul Smith (from “Obama’s Trauma Team”) tells us the tale of how Go played a big role in the rescuing and rebuilding of the HealthCare.gov website. Along the way we learn what the original team did wrong, how the rescue team kept it afloat during huge traffic spikes, and what they’ve done since to rebuild it to serve the people’s needs.
Jan 12, 2023
A special New Year's fireside chat
Mat and the gang ring in the new year by gathering around a make believe fireplace and discussing what they’re excited about in 2023, their new years resolutions & a little bit of Go talk, too. But only a little.
Jan 05, 2023
Making Go more efficient
Mat invites Bartłomiej Płotka, Kemal Akkoyun & Christian Simon to discuss how to make Go code more efficient through modern observability practices.
Dec 15, 2022
Hacking with Go: Part 3
Ivan Kwiatkowski joins Natalie once again for a follow-up episode to Hacking with Go: Part 2. This time we’ll get Ivan’s perspective on the way Go’s security features are designed and used, from the user/hacker perspective. And of course we will also talk about how AI fits into all this…
Dec 08, 2022
To TDD or not to TDD
That is the question. Whether ’tis nobler in the mind to suffer the slings and arrows of outrageous test coverage, or to take arms against a sea of bugs…
Dec 01, 2022
How Pinterest delivers software at scale
Nishant Roy, Engineering Manager at Pinterest Ads, joins Johnny & Jon to detail how they’ve managed to continue shipping quality software from startup through hypergrowth all the way to IPO. Prepare to learn a lot about Pinterest’s integration and deployment pipeline, observability stack, Go-based services and more.
Nov 24, 2022
gRPC & protocol buffers
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.
Nov 17, 2022
Debugging Go
Natalie & Ian welcome Liran Haimovitch & Tiago Queiroz to the show for a discussion focused on debugging Go programs. They cover good & bad debugging practices, the difficulty of debugging in the cloud, the value of errors logs & metrics, the practice of debugging in production (or not) & much more!
Nov 10, 2022
Go in medicine & biology
Today we’re talking about uses for Go in the medical industry. Tim Stiles develops and maintains a Go package for synthetic biology and molecular biology called Poly. It has broad applications for biotech R&D, but also has very direct applications to medicine.
Nov 04, 2022
Spooky stories to scare devs 👻
Mat Ryer gathers a gang of ghouls and ghosts to tell spooky developer stories! Join us to hear tales of Mat’s $1k nightmare, Dee’s infinite loop of horror, Natalie’s haunted time as a junior dev & many, many more.
Oct 27, 2022
Who owns our code?
In this episode, we’re joined by tech Lawyer Luis Villa to explore the question, who owns code? The company, the engineer, the team? What about when you’re using AI, Machine learning, GitHub Copilot… is that still your code?
Oct 20, 2022
Hacking with Go: Part 2
We’re once again exploring hacking in Go from the eyes of security researchers. This time, Natalie & Ian are joined by Ivan Kwiatkowski (a.k.a. Justice Rage)!
Oct 13, 2022
Mat's GopherCon EU diary
Join Mat Ryer on his journey to Berlin for GopherCon EU 2022. Along the way he chats with Egon Elbre, Ale Kennedy, Ole Bulbuk, Christian Haas, Bill Kennedy & Ron Evans. Danke!
Oct 07, 2022
Functional programming with generics?
We did an episode on functional programming in Go with Aaron Schlesinger back in 2019… But that was before generics were a thing. Let’s revisit the topic and discuss the pros and cons now that we have generics. What’s changed? What hasn’t?
Sep 30, 2022
Engineering interview tips & tricks
In this episode, we will be exploring interviewing as a Software Engineer. Tips, tricks, and gotchas, as well as potentially some interviewing horror stories and red flags to avoid at all costs. We’re joined by Emma Draper, Engineering Manager at the New York Times based in Arizona, and Kate Jonas, goes by Jonas, Technical Enablement Manager at Datadog based in Denver.
Sep 22, 2022
Stay agile out there
Inbal Cohen, Product expert and Agile evangelist, joins Natalie & Angelica for a conversation about all things Agile. Inbal lays out some agile tips for Go devs, discusses if and how remote work changes things, describes some downsides of the methodology, and more.
Sep 15, 2022
Avoiding bloat
Egon Elbre and Roger Peppe join Mat for a conversation all about bloat (and how to avoid it). Expect talk of code bloat, binary bloat, feature bloat, and an even-more-bloated-than-usual unpopular opinion segment.
Sep 08, 2022
Inside GopherCon
Ever wondered how GopherCon came to be, and how it’s put together every year. In this show we will be chatted with Erik St. Martin, who has been there from the start about how GopherCon came to be, how this year’s conference came together, as well as why events like GopherCon as so great! We are joined by Erik St. Martin, GopherCon Organizer and Co-Author Go in Action.
Sep 01, 2022
The art of the PR: Part 2
In this episode, we’ll be further exploring PRs. Check out The art of the PR: Part 1 if you haven’t yet. What is it that makes a PR a good PR? How do you consider PRs in an open source repo? How do you vet contributions from people who aren’t a part of the repository? How does giving feedback and encouragement fit in to the PR process? We’ll be debating the details, and trying to help our fellow gophers perfect the art of the PR. We are joined by the awesome Anderson Queiroz, hosted by Natalie Pistunovich & Angelica Hill.
Aug 27, 2022
The art of the PR: Part 1
In this episode, we will be exploring PRs. What makes a good PR? How do you give the best PR review? Is there such thing as too small, or big of a PR? We’ll be debating the details, and trying to help our fellow gophers perfect the art of the PR. We are joined by three wonderful guests Jeff Hernandez, Sarah Duncan, and Natasha Dykes. Hosted by Angelica Hill & Natalie Pistunovich.
Aug 18, 2022
The pain of dependency management
Baruch Sadogursky (Chief Sticker Officer at JFrog) joins Natalie & Johnny to lament the current state of dependency management in Go and other languages. They discuss the problems dependency managers face, possible technical mitigations like SBOMs, people problems that will never be solved by tech, and take questions from listeners in the #gotimefm channel of Gophers Slack.
Aug 11, 2022
Gophers Say! GopherCon EU Edition
Our award winning worthy survey game show is back, this time Mat Ryer hosts it live on stage at GopherCon Europe 2022! Go Time’s Natalie Pistunovich joins forces with Ronna Steinberg & Robert Burke to battle it out with V Körbes, Tamir Bahar & Konrad Richie. Let’s see who can better guess what the GopherCon Europe gophers had to say!
Aug 04, 2022
What's new in Go 1.19
Go 1.18 was a major release where we saw the introduction of generics into the language as well as other notables such as fuzzing and workspaces. With Go 1.19 slated to come out next month, one has to wonder what’s next. Are we in store to be blown away by new and major features like we saw in 1.18? Not exactly but there are still lots of improvements to be on the lookout for. Joining Mat & Johnny to touch on some of the most interesting ones is Carl Johnson, himself a contributor to the 1.19 release.
Jul 28, 2022
Go for beginners ♻️
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.
Jul 21, 2022
Might Go actually be OOP?
A conversation with Ronna Steinberg, who was an OOP developer for many years, and now is a Go Google Developer Expert. Ronna has been thinking about Go and OOP for awhile, asking herself whether or not Go is an object oriented programming language. Tune in to find out her answer and hear some of the options gophers have for object oriented design.
Jul 14, 2022
Go tooling ♻️
We’re talking about the tools we use every day help us to be productive! This show will be a great introduction for those new to Go tooling, with some discussion around what we think of them after using some of them for many years.
Jul 07, 2022
Thoughts on velocity
A deep discussion on that tension between development speed and software quality. What is velocity? How does it differ from speed? How do we measure it? How do we optimize it?
Jun 30, 2022
2053: A Go Odyssey
The year is 2053. The tabs-vs-spaces wars are long over. Ron Evans is the only Go programmer still alive on Earth. All he does is maintain old Go code. It’s terrible! He must find a way to warn his fellow gophers before it’s too late. Good thing he finally got that PDQ transmission system working…
Jun 23, 2022
Observability in the wild: strategies that work
This week we’re featuring an episode of Grafana’s Big Tent! LEGO Group principal engineer Nayana Shetty swaps observability survival stories (to drill or not to drill?) with hosts Mat Ryer and Matt Toback. The trio also reveals new and different observability strategies that have been successful and effective in their organizations. Plus: Nayana shares how she built her successful observability career brick by brick.
Jun 16, 2022
Going through the news
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.
Jun 09, 2022
The myth of incremental progress
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.
Jun 02, 2022
Berlin's transition to Go
The Berlin tech ecosystem was all about PHP/Python for a long time. In the recent years it became a tech hub and an early adopter of Go. In this conversation we’ll see how this reflects in the 10+ years old Go meetup, with the meetup organizing team.
May 26, 2022
Revisiting Caddy
Matt Holt & Mohammed S. Al Sahaf sit down with Natalie & Jon to discuss every gopher’s favorite open source web server with automatic HTTPS! In addition to laying out what Caddy is and why it’s interesting, we dive deep into how you can (and why you might want to) extend Caddy as a result of its modular architecture.
May 19, 2022
What to do when projects get big and messy
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.
May 12, 2022
Go and PHP sitting in a tree...
Can Go help you write faster PHP apps? In this episode, we explore the unusual pairing of Go and PHP that led to the RoadRunner project, a high-performance PHP application server, load-balancer, and process manager that is all written in Go.
May 05, 2022
Analyzing static analysis
Matan Peled from Technion University joins Natalie & Mat to discuss his PhD research on meta programming and static analyzers. How does Go’s measure up? What would Matan’s look like if he built one? All that and more!
Apr 28, 2022
Instrumentation for gophers
Björn Rabenstein & Bartlomiej Płotka join Mat & Johnny to discuss observability, monitoring and instrumentation for gophers.
Apr 21, 2022
Go code organization best practices
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.
Apr 14, 2022
Answering questions for the Go-curious
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!
Apr 07, 2022
How can we prevent legacy from creeping in?
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.
Mar 31, 2022
Making the command line glamorous
This week we’re bringing The Changelog to Go Time — we had an awesome conversation with Toby Padilla, Co-Founder at Charm where they’re building tools to make the command line glamorous. Toby and the team at Charm have gone “all in” on Go — all of Charm is written in Go. They moved to Go from other languages, saying “Go is the answer to building these type of tools.” And even on this episode Toby says “I love Rust, it’s really cool, it’s a super-exciting language, but I jumped ship. I wanna be more productive, I wanna use all the fun toys, and so I started doing Go.” Clearly this episode will be in good company here on Go Time. We talk about the state of the art, the next big thing happening on the command line and in ssh-land. They have an array of open source tooling to build great apps for the terminal and Charm Cloud to power a new generation of CLI apps. We talk through all their tooling, where things are headed for CLI apps, the focus and attention of their team, and what’s to come in bringing glamor to the command line.
Mar 25, 2022
Mastering 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.
Mar 17, 2022
Bob Logblaw Log Blog
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.
Mar 10, 2022
Why immutable databases?
Let’s talk about the concept of immutable databases, the problems they target, and why you’d want to build one in Go.
Mar 03, 2022
Going with GraphQL
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?
Feb 24, 2022
The *other* features in Go 1.18
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!
Feb 17, 2022
Building and using APIs with Go
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.
Feb 10, 2022
MLOps in Go
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?
Feb 03, 2022
Migrations without migraines
One of the most common questions we receive at Go Time is how to handle schema migrations in Go. In this episode Jon is joined by Mike Fridman and Vojtech Vitek, maintainers of the popular schema migration tool pressly/goose, to discuss techniques, tools, and tips for handling schema migrations.
Jan 27, 2022
AI-driven development in Go
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?
Jan 20, 2022
Go beyond work
Our final installment from GopherCon 2021 is an awesome panel conversation led by Natalie & Angelica with guests Linus Lee, Daniela Patruzalek, and Sebastian Spank. All three of these gophers are using Go in cool and interesting ways outside of traditional work projects.
Jan 13, 2022
Gophers Say! GopherCon Edition
Our award winning ready survey game show is back, this time live from GopherCon 2021! Go Time panelists Natalie & Jon join forces with Go Team members Steve Francia, Katie Hockman, Julie Qui, and Rob Findley to battle it out and see who can better guess what the GopherCon gophers had to say!
Jan 06, 2022
The funny bits from 2021
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.
Jan 03, 2022
Mat asks the Go Team anything
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.
Dec 16, 2021
Coding Go in the blind
In this episode Dominic speaks with Jon about his experience transitioning to using a screen reader and learning to code without his vision. They discuss how some of the tooling works, things other developers can do to make their code more accessible for blind teammates, and more.
Dec 09, 2021
Our first decade with Go
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.
Dec 02, 2021
Maintenance in the open
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.
Nov 25, 2021
Eventually consistent (managing data at scale)
Tiago Mendes joins Mat, Jon, and Johnny to discuss eventual consistency and strategies for changing data at scale.
Nov 18, 2021
Hacking with Go: Part 1
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.
Nov 11, 2021
Discussing Go's annual developer survey
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.
Nov 04, 2021
Just about managing
Ashley Willis and Ela Krief join Natalie to discuss the ins and outs of management. They discuss what makes a good manager, common mistakes managers make, how to communicate effectively, dealing with conflict, and much more.
Oct 28, 2021
Maintaining ourselves
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.
Oct 21, 2021
eBPF and Go
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.
Oct 14, 2021
Gophers Say What!?
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!
Oct 07, 2021
Go on hardware: TinyGo in the wild
In this episode, we will be exploring the tiny world of Go and Hardware. We are joined by three gophers, Vladimir Vivien, Tobias Theel, and Ron Evans, who will be discussing the use of Linux API (V4L2) to control video hardware and capture image data in realtime, programming Bluetooth devices, working on WiFi communication using an Arduino Nano 33 IoT NINA chip, and much more.
Sep 30, 2021
The little known team that keeps Go going
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.
Sep 23, 2021
Books that teach Go
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!
Sep 16, 2021
Building actually maintainable software
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”.
Sep 09, 2021
To build, or to buy, that is the question
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.
Sep 02, 2021
Don't forget about memory management
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.
Aug 26, 2021
Caddy V2
Matt Holt joins Jon Calhoun to discuss Caddy, its history, and the process of creating a v2 of the popular web server. In the episode they discuss some of the challenges encountered while building the v2, reasons for doing a major rewrite, and more.
Aug 19, 2021
Data streaming and Benthos
Mihai and Ashley join Jon to discuss data streaming. What is it, why is it being used, and common mistakes developers make when setting up. They also discuss some of the tools in the ecosystem, including Benthos, a tool created by Ashley Jeff’s to make the plumbing part of data streaming easier to get right.
Aug 12, 2021
Opening up the opinion box
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.
Aug 05, 2021
How to make mistakes in Go
The panel are joined by Teiva Harsanyi, author of 100 Go Mistakes, to talk about how best to make mistakes when writing Go.
Jul 29, 2021
Do devs need a product manager?
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.
Jul 22, 2021
SIV and the V2+ issue
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.”
Jul 15, 2021
Fuzzing in the standard library
Fuzzing is coming to the standard library. We speak to Katie Hockman and Jay Conrod who were part of the team responsible for designing and implementing it. We dig into the details, hear some best practices, where fuzzing can help your code, and learn more about how it works.
Jul 08, 2021
Pop quiz time! 😱
Learning Go with code pop quizzes is a fun way to zoom in on different language features. People are looking forward to pop quizzes on Twitter and in conferences, and they also learn from that. Let’s chat about pop quizzes!
Jul 01, 2021
Giving TDD a Go
We discuss how Test Driven Development (TDD) can help you write better code, and build better software. Packed with tips and tricks, gotchas and best practices, the panel explore the subject and share their real-world experiences.
Jun 24, 2021
All about Porter
Porter lets you package your application artifacts, client tools, configuration and deployment logic together as a versioned bundle that you can distribute, and then install with a single command. Written entirely in Go, we speak to one of the creators about running an open source project, the importance of documentation, and more.
Jun 17, 2021
Using Go in unusual ways
This episode was recorded live from GopherCon Europe 2021! Natalie & Mat host three amazing devs who gave talks that showcase using Go in unusual ways: Dr. Joakim Kennedy is tracking Go in malware, Mathilde Raynal is building quantum-resistant cryptography algorithms, and Preslav Rachev is creating digital art. We hear from our speakers how they got into Go, how they made the choice to use Go for their unusual use case, and how it compares to other languages for their specific needs. We also chat about conference talks, submissions and public speaking - how to start, good practices, and tips they collected along the way.
Jun 10, 2021
Go Battlesnake Go!
In the past decade a variety of games have emerged where players need to create an AI to play the game rather than play the game directly. In this episode we speak with the creator of one of those games - Battlesnake. Brad Van Vugt joins us to talk about building a game engine using Go, making programming games easier for beginners to get started with, the long term vision for games like Battlesnake, and more.
Jun 03, 2021
Building for Ethereum in Go
In this episode, we will talk about building for Blockchain in Go. We are joined by two of the co-founders of Prysmatic Labs (a company behind the upgrades to the Ethereum network). Raul Jordan and Preston Van Loon tell Angelica how they started the company, as well as what it’s like to build technical infrastructure for the Ethereum blockchain using Go.
May 27, 2021
Are frameworks getting an Encore?
Tools and frameworks that aim to boost developer productivity are always worth a closer look, but we don’t often consider the trade-offs for whichever we settle on. In this episode, we discuss the questions one should be asking when evaluating developer productivity tools and frameworks in the Go ecosystem in particular. Joining us to discuss is André Eriksson, the creator of Encore, a backend framework that aims to make development and deployment as productive as it can be.
May 20, 2021
Event-driven systems
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.
May 13, 2021
What makes wonderful workshops?
Perspectives from both the workshop leaders perspective, as well as the workshop participants. What are some top tips, things to watch out for, and ways to innovate and keep your participants engaged, especially in the remote world we are now living in.
May 06, 2021
Building startups with Go
Startups are all about iterating quickly, building MVPs, and finding that elusive product market fit, so how does Go fit into that picture? Is Go a good choice for startups, or is it exclusively for the larger corporations? In this episode Jon is joined by four startup founders to learn about their experience building a startup with Go.
Apr 29, 2021
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.
Apr 22, 2021
The ultimate guide to crafting your GopherCon proposal
The Call for Proposals for GopherCon 2021 is open from Monday, April 5th to Sunday, April 25th. Kris Brandow, an experienced GopherCon speaker, has published a series of guides to assist Gophers as they craft their proposals and think about submitting. In this episode Kris reads through his guide, discussing the four parts with a GopherCon newbie, Angelica Hill, who spoke for the first time at GopherCon last year, and is a first time CFP reviewer this year.
Apr 15, 2021
Trials and tribulations of testing in Go
Testing can be hard, how to test, where to test, what is a good test? All questions that can be deceptively difficult to answer. In this episode we talk about the trials and tribulations of testing and why it can be argued to be especially difficult in Go.
Apr 08, 2021
Releasing with (and without) GoReleaser
Carlos Alexandro Becker joins Mat, Natalie, & Johnny to discuss the ins and outs of releasing your Go code. Carlos created and maintains GoReleaser, a popular tool that helps you deliver your Go binaries as fast and easily as possible.
Apr 01, 2021
Design philosophy
In this insight-filled episode, Bill Kennedy joins Johnny and Kris to discuss best practices around the design of software in Go. Bill talks through scenarios, lessons learned, and pitfalls to avoid in both architecture and coding of Go projects.
Mar 25, 2021
Carl (Director of Technology for Spotlight PA) and Wayne (Principal Engineer at GoDaddy) join Mat and Mark to talk about the new go:embed feature in Go 1.16. They discuss how and when to use it, common gotchas to watch out for, and some rather meaty unpopular opinions thrown in for good measure.
Mar 18, 2021
Talkin' 'bout code generation
O.G. Brian Ketelsen joins the panel to discuss code generation; programs that write programs. They also discuss IDLs, DSLs, overusing language features, generics, and more. Also Brian plays his guitar. 🤘
Mar 11, 2021
Go at Clever
In this episode we explore how Clever started using Go. What technologies did Clever start with, how did they transition to Go, and what were the motivations behind those changes? We then explore some of the OS tech written by the team at Clever.
Mar 04, 2021
Indecent (language) Proposals: Part 2
This is the second part of a discussion about Go language proposals that may or may not make it into the language. Listen to part one as well!
Feb 25, 2021
The art of reading the docs
Documentation. You can treat it as a dictionary or reference manual that you look up things in when you get stuck during your day-to-day work OR (and this is where things get interesting) you can immerse yourself in a subject, domain, or technology by deeply and purposefully consuming its manuals cover-to-cover to develop expertise, not just passing familiarity. In this episode we pull in perspectives and anecdotes from beginners and veterans alike to understand the impact of RTFM deeply. Also Sweet Filepath O’ Mine?!?!
Feb 18, 2021
Indecent (language) Proposals: Part 1
In this episode, we discuss some proposed changes to Go covering a range of subjects, from magical interfaces, to enhancing range loops, make and new with inferred types, lazy values, and more. We also talk a lot about ints, so get this episode in your ears.
Feb 11, 2021
When Go programs end
Michael Knyszek from the Go team joins us to talk about what happens when a program ends. How are file handles cleaned up? When are deferred functions run, and when are they skipped entirely? Is there a way to terminate all running goroutines? Tune in to learn the answers to these questions and more!
Feb 04, 2021
Why writing is important
In this episode we talk about various types of writing and how we as Go developers can learn from them. Whether it is planning and preparing to write, communicating with team members, or making our code clearer for future developers to read through style guides.
Jan 28, 2021
CUE: Configuration superpowers for everyone
On this episode we learn how to Configure, Unify, and Execute things. What’s CUE all about? Well, it’s an open source language with a rich set of APIs and tooling for defining, generating, and validating all kinds of data: configuration, APIs, database schemas, code, … you name it. Now that we’ve copy/pasted the project’s description… let’s dig in and learn how we can use CUE to make our Go programs better!
Jan 21, 2021
We're talkin' CI/CD
Continuous integration and continuous delivery are both terms we have heard, but what do they really mean? What does CI/CD look like when done well? What are some pitfalls we might want to avoid? In this episode Jérôme and Marko, authors of the book “CI/CD with Docker and Kubernetes” join us to share their thoughts.
Jan 14, 2021
Go Panic!
Mat Ryer hosts our don’t-call-it-jeopardy game show live at GopherCon! Kat Zień, Mark Bates, and L Körbes put their Go knowledge to the test! Can you outwit our intrepid contestants?
Jan 07, 2021
Go in other spoken languages
L Körbes– creator of Aprenda Go– joins our panel of gophers to discuss teaching and learning Go in non-English languages. Along the way: Mat reveals his origin story, Kris explains why all idioms are garbage, and Natalie gives conference tips.
Dec 17, 2020
What to expect when you’re NOT expecting
Mat Ryer hosts a spectacular panel with expert debuggers Derek Parker, Grant Seltzer Richman, and Hana Kim from the Go Team. Let’s face it, even the best-intended code doesn’t always do what you want it to. What’s a Gopher to do? Listen to this, that’s what!
Dec 10, 2020
The engineer who changed the game
Today we’re sharing a full-length episode of Command Line Heroes from Season 6 for you to check out. We hand picked this episode for you to listen to. Many of us grew up playing cartridge-based games. But there’s few who know the story behind how those cartridges came to be. And even fewer who know the story of the man behind them: Jerry Lawson. Before Jerry, a gaming console could only play one game. Jerry quite literally changed the game. This episode shares Jerry’s story of inventing the cartridge-based system for gaming consoles.
Dec 04, 2020
Play with Go
Play with Go is a set of hands-on, interactive tutorials for learning the tools used while programming in Go. In this episode we are joined by its creators, Paul Jolly and Marcos Nils, as we learn more about what motivated the creation of the project, what technology it was built on, and how you can help contribute additional guides to help your fellow gophers!
Dec 03, 2020
The secret life of gophers
Join Mat Ryer for a fun conversation with Kris Brandow, Angelica Hill, and Natalie Pistunovich about how these Gophers get work/life done in this crazy world! Expect to learn about work environment must-haves, communication tips & tricks, developer tool recommendations, and much more!
Nov 26, 2020
When distributed systems Go wrong
Monitoring and debugging distributed systems is hard. In this episode, we catch up with Kelsey Hightower, Stevenson Jean-Pierre, and Carlisia Thompson to get their insights on how to approach these challenges and talk about the tools and practices that make complex distributed systems more observable.
Nov 19, 2020
What would you remove from Go?
When we talk about improving a programming language, we often think about what features we would add. Things like generics in Go, async/away in JS, etc. In this episode we take a different approach and talk about what we would remove from Go to make it better.
Nov 12, 2020
How Go helped save HealthCare.gov
Paul Smith (from “Obama’s Trauma Team”) tells us the tale of how Go played a big role in the rescuing and rebuilding of the HealthCare.gov website. Along the way we learn what the original team did wrong, how the rescue team kept it afloat during huge traffic spikes, and what they’ve done since to rebuild it to serve the people’s needs.
Nov 05, 2020
GitHub's Go-powered CLI
In this episode we discuss Mislav’s experience building not one, but two Github CLIs - hub and gh. We dive into questions like, “What lead to the decision to completely rewrite the CLI in Go?”, “How were you testing the CLI, especially during the transition?”, and “What Go libraries are you using to build your CLI?”
Oct 29, 2020
With Gophercon rapidly approaching, we go behind the scenes to find out what it takes to deliver the world’s largest Go conference.
Oct 22, 2020
Introducing your team to Go
Can’t find a job working in Go? Perhaps introducing your current team to Go is the solution. In this episode we talk about how Go was introduced at different organizations, potential pitfalls that may sabotage your efforts, some advice on how to convince your team and CTO to use Go and more.
Oct 15, 2020
Cloud Native Go
What is cloud native? In this episode Johnny and Aaron explain it to Mat and Jon. They then dive into questions like, “What problems does this solve?” and “Why was Go such a good fit for this space?”
Oct 08, 2020
There's a lot to learn about teaching Go
In this episode we dive into teaching Go, asking questions like, “What techniques work well for teaching programming?”, “What role does community play in education?”, and “What are the best ways to improve at Go as a beginner/intermediate/senior dev?”
Oct 01, 2020
The one with Brad Fitzpatrick
Brad Fitzpatrick returns to the show (last heard on episode 44) to field a mixed bag of questions from Johnny, Mat, and the live listeners. How’d he get in to programming? What languages did he use before Go? What’s he up to now that he’s not working on the Go language? And of course… does he have any unpopular opinions he’d like to share? 😏
Sep 24, 2020
Community Q&A
A community Q&A special. You asked the questions, and we discussed them live on air. A few example questions include “When is it okay to use init?”, “When should we use constructors?”, and “How should Go code be structured?”
Sep 17, 2020
Hits of the Summer
This episode is different than what you’re used to. We’ve been clipping highlights of the show for awhile now to share on Twitter and YouTube. A side effect of that effort is a bunch of awesome clips just sitting on Jerod’s hard drive collecting digital dust. So, here’s a beta test of a “best of” style clips show covering the summer months. Let us know if you like it!
Sep 10, 2020
A deep dive on Fuzzing and a close look at the official Fuzzing proposal for Go.
Sep 03, 2020
Building desktop apps with Go + web tech
Building desktop applications is tricky. Every OS has its own set of tools, and you often need to learn a new language for each. In this episode we talk with Wails creator Lea Anthony about how the build tool enables developers to create desktop apps using Go and their normal JS frontend (React, Vue, Anguluar, or whatever you want).
Aug 27, 2020
Francesc Campoy and Isobel Redelmeier joins the panel to discuss Go’s context package including real-world insights into its use and misuse.
Aug 20, 2020
All about that infra(structure)
Infra, Devops, Systems Engineer, SRE, and the list goes on and on. What do these terms mean? Why does every job listing for the same role seem to entail different responsibiliities? Why is it important for developers to be familiar with the infrastructure their code is running on? Tune in to gain some insights into all of this and more!
Aug 13, 2020
JSON (JavaScript Object Notation) is used all over the web as a text-based way of transmitting data. In this episode, we explore Go’s encoding/json package, and others with Daniel Marti.
Aug 06, 2020
The latest on Generics
Robert and Ian join us to talk about the latest updates on generics in Go. What type of feedback are they looking for as developers get their hands on tools designed to experiment with generics and Go? What was the deal with the featherweight Go paper that also discussed generics? Why can’t we use angle brackets for generics?
Jul 30, 2020
The future of Testify
The panel discuss testing frameworks in Go. After a brief overview of the concepts involved, we discuss how testing frameworks can make our lives easier, and why some people still choose to avoid them. Mat Ryer and Mark Bates chat with Boyan Soubachov about the future of the Testify project.
Jul 23, 2020
Your first week with Go
Your first week with a new programming language can be tricky. In this episode Jon is joined by Jacquie and DaShaun to talk about their first week with Go. What was their primary focus? What resources did they leverage? What made it stick, and what didn’t?
Jul 16, 2020
Focusing in on PostgreSQL
Choosing a database is hard. They each have their pros and cons, and without much experience it is hard to determine which is the best fit for your project. In this episode Johan Brandhorst joins us to talk about Postgres. When is it a good fit? How well does it scale? What libraries exist in Go for using Postgres?
Jul 09, 2020
Go in production at Pace.dev
Building a new app in Go can involve a lot of technical decisions. How will your code be structured? How will you handle background jobs? What will your deploy process look like? In this episode we will walk through the decisions made while building the public release of Pace.dev.
Jul 02, 2020
We have regrets
Leaning from mistakes is key to progressing. In this episode Ben, Aaron, Kris, and Jon discuss some of our mistakes - like spending too much time designing a feature that isn’t that important, or using channels excessively when first learning Go - and how we learned from them.
Jun 25, 2020
Mat Ryer talks to a new full-time Go programmer, an intern at Google, and a high-school programmer about the tech world from their perspective.
Jun 19, 2020
Reflection and meta programming
Mat, Jon, and Jaana discuss reflection and meta programming. How do other languages use reflection, and how does that differ from Go’s approach? What libraries are using reflection well? What are some examples of bad times to use reflect? What alternative approaches exist? And what are those weird struct tags I keep seeing in Go code?
Jun 11, 2020
The trouble with databases
Databases are tricky, especially at scale. In this episode Mat, Jaana, and Jon discuss different types of databases, the pros and cons of each, along with the many ways developers can have issues with databases. They also explore questions like, “Why are serial IDs problematic?” and “What alternatives are there if we aren’t using serial IDs?” while at it.
May 28, 2020
On community and safety
Johnny and Jon are joined by Denise to talk about her role at GitHub and what the community and safety team does to help open source project creators and contributors, GoCon Canada and the role of organizing a conference, and more.
May 21, 2020
Challenges of distributed messaging systems
Distributed systems are hard. Building a distributed messaging system for these systems to communicate is even harder. In this episode, we unpack some of the challenges of building distributed messaging systems (like NATS), including how Go makes that easy and/or hard as applicable.
May 14, 2020
Black Hat Go
Put on your dark hoodie, turn all the lights off, and join the author of Black Hat Go as we explore the darker side of Go.
May 07, 2020
Immediate mode GUIs
Mat, Johnny and Jon are joined by Elias, creator of Gio, to discuss GUIs. Specifically, we explore the pros and cons of immediate vs retained mode and explore some examples of each, as well how some frameworks like React are attempting to bring the benefits of immediate mode to a retained mode world (the DOM).
Apr 30, 2020
WebRTC in Go
The gang discusses WebRTC with Sean DuBois, creator of the Pion project and author of a pure Go WebRTC implementation. What exactly is WebRTC? Why is it so popular for video chatting? How does it work under the hood, and how does it compare with other real-time communication options?
Apr 23, 2020
The monolith vs microservices debate
What is a microservice, and what is a monolith? What differentiates them? When is a good time for your team to start considering the transition from monolith to microservice? And does using microservices mean you can’t use a monorepo?
Apr 16, 2020
Organizing for the community
What does it take to organize a community event? How do you ensure it is diverse? What does diversity even mean? Tune in to learn directly from organizers of some of the most diverse Go meetups (Gophercon EU and Go Bridge).
Apr 09, 2020
Enterprise Go?
Bryan Liles joins Johnny and Mat for a wide-ranging discussion that starts with the question: what even is enterprise Go?
Apr 02, 2020
Working from home can be challenging, especially amid school closings and everything else caused by COVID-19. In this episode panelists Jon, Mat, Carmen, and Mark share advice and experiences they have accumulated over many years of working from home. They cover separating your work space from your personal space, signaling to your family that you are busy, ways to keep track of the time, and suggestions for getting some exercise in when you can.
Mar 26, 2020
The Zen of Go
Dave Cheney talks to us about the Zen of Go (ten engineering values for writing simple, readable, maintainable Go code). What makes code good in Go? What guiding principles should we bear in mind when writing Go?
Mar 19, 2020
It is Go Time!
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.
Mar 16, 2020
Pow! Pow! Power tools!
Johnny and John welcome Thorsten Ball back to the show. This time we’re talking power tools! Editors, operating systems, containers, cloud providers, databases, and more. You name it, we probably talk about.
Mar 12, 2020
On the verge of new AI possibilities
In this episode Jaana and Mat are joined by Daniel and Miriah to dive into AI in Go. Why has python historically had a bigger foothold in the AI scene? Is machine learning in Go growing? What libraries and tools are out there for someone looking to get started with AI? And where do you start if you don’t have enough data for your own models?
Mar 05, 2020
Stop the presses
Newsletters play a unique role for developers. As the Go community continues to grow and mature, these newsletters provide a much-needed filter for the oft overwhelming stream of new articles, talks, and libraries produced by the community on a weekly basis. In this episode Johnny, Jon, and Mat are joined by Peter Cooper of the Golang Weekly newsletter to discuss his role as a newsletter curator. We explore difficult topics that touch on ethics and responsibilities of a curator and of course, the impact Peter and his team have on shaping, at least in part, what many in the Go community get exposed to.
Feb 27, 2020
Quack like a wha-?
Interfaces are everywhere in Go. The basic error type is an interface, writing with the fmt package means you are probably using an interface, and there are countless other instances where they pop up. In this episode Mark, Mat, Johnny, and Jon discuss interfaces at length, exploring what they are, how they are using them in their own projects, as well as tips for how you can leverage them in your own code.
Feb 20, 2020
Telemetry and the art of measuring what matters
Telemetry is tricky to get started with. What metrics should you be tracking? Which metrics are important? Will they help you predict and avoid potential issues? When is a good time to start? Should you put it off until later? In this episode we discuss some common metrics to collect, how to get started with telemetry, and more with guest Dave Blakey of Snapt.
Feb 13, 2020
Unusual uses for Go: GUIs
Johnny and Jon are joined by Andy Williams to talk about some of the unusual ways developers are using Go. In this particular episode they deep dive into building GUIs and discuss all of the challenges imposed by trying to build a UI that is both cross platform and functional. How do you create buttons that work on both mobile and a desktop app? Should you even be designing both apps at the same time? Tune in to find out!
Feb 06, 2020
Grokking Go.dev
Carmen, Mat, and Jon are joined by Steve Francia and Julie Qiu to discuss the new Go.dev website. What was the motivation behind it? What technology was used to build it? How are they working to make package discovery better? And what resources are there to help you convince your manager to use Go on that upcoming project?
Jan 30, 2020
Cloudy with a chance of Kelsey Hightower
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.
Jan 21, 2020
Go at Heroku
We teamed up with some friends of ours at Heroku to promote the Code-ish podcast so we’re sharing a full-length episode right here in the Go Time feed. This episode features Johnny Boursiquot (Go Time panelist) on the mic with guests Edward Muller and Rishabh Wason talking about Go at Heroku. Learn more and subscribe at heroku.com/podcasts/codeish.
Jan 16, 2020
Go at Cloudflare
Jaana, Jon, and Mat are joined by John Graham-Cumming, the CTO of Cloudflare, to discuss Go at Cloudflare along with John’s unique involvement in Gordon Brown’s apology to Alan Turing. How did Cloudflare get started with Go? What problems do they use Go for and when to they turn to other languages? And how exactly did John’s petition for an apology to Turing get so popular?
Jan 14, 2020
defer GoTime()
Mat, Carmen, and Jon are joined by Dan Scales to talk about Mat’s favorite keyword in Go - defer. Where did the defer statement come from? What problems can it solve? How has it shaped how we write Go code? How are other languages solving similar problems? And what exactly was changed in Go 1.14 to improve the performance of defer?
Jan 07, 2020
Bugs are in the air
Guests are catching the bug, so we decided to spend this episode talking about bugs! How do you find and fix your bugs? Do you sketch things out, whip out the debugger, or something else?
Dec 24, 2019
The fireside edition 🔥
Grab a hot beverage and a warm blanket because it’s time for a fireside chat with the Go Time panel! We discuss many topics of interest: what we’d build if we had 2 weeks to build anything in Go, the things about Go that “grind our gears”, our ideal work environments, and advice we’d give ourselves if we were starting our career all over again.
Dec 17, 2019
Concurrency, parallelism, and async design
Go was designed with concurrency in mind. That’s why we have language primitives like goroutines, channels, wait groups, and mutexes. They’re very powerful when used correctly, but they can be very complicated if used unwisely. Roberto Clapis joins the team once again to drop async wisdom in your ears. Don’t worry, we do it in serial. 😉
Dec 10, 2019
Graph databases
Mat, Johnny, and Jaana are joined by Francesc Campoy to talk about Graph databases. We ask all the important questions — What are graph databases (and why do we need them)? What advantages do they have over relational databases? Are graph databases better at answering questions you didn’t anticipate? How is data structured? How do queries work? What problems are they good at solving? What problems are they not suitable for? And…since we had Francesc on the hot seat, we asked him about Just for Func and when it’s coming back.
Nov 27, 2019
Compilers and interpreters
Thorsten Ball and Tim Raymond join Mat Ryer and Mark Bates to talk about compilers and interpreters. What are the roles of compilers and interpreters? What do they do? The how and why of writing a compiler in Go. We also talk about Thorsten’s books “Writing an Interpreter in Go” and “Writing a Compiler in Go.”
Nov 22, 2019
Code editors and language servers
In this episode we talk with Ramya Rao about code editors and language servers. We share our thoughts on which editor we use, why we use it, and why we’d switch. We also discuss what a language server is and why it matters in connecting editors and the languages they support. We also dive into various ways to be effective with VS Code including shortcuts, plugins, and more.
Nov 11, 2019
Kubernetes and Cloud Native
Johnny and Mat are joined by Kris Nova and Joe Beda to talk about Kubernetes and Cloud Native. They discuss the rise of “Cloud Native” applications as facilitated by Kubernetes, good places to use Kubernetes, the challenges faced running such a big open source project, Kubernetes’ extensibility, and how Kubernetes fits into the larger Cloud Native world.
Nov 01, 2019
Building search tools in Go
Johnny is joined by Marty Schoch, creator of the full-text search and indexing engine Bleve, to talk about the art and science of building capable search tools in Go. You get a mix of deep technical considerations as well as some of the challenges around running a popular open source project.
Oct 24, 2019
All about caching
Manish Jain and Karl McGuire of Dgraph join Johnny and Jon to discuss caching in Go. What are caches, hit rates, admission policies, and why do they matter? How can you get started using a cache in your applications?
Oct 17, 2019
On application design
Mat is joined by Peter Bourgon, Kat Zień, and Ben Johnson to talk about application design in Go — principles, trade-offs, common mistakes, patterns, and the things you should consider when it comes to application design.
Oct 09, 2019
Security for Gophers
Mat, Filippo, Johan, and Roberto discuss security in Go. Does Go make it easy to secure your code? What common mistakes are Gophers making? What is fuzzing? How can attackers abuse your code if you use the default http mux?
Oct 03, 2019
Creating the Go programming language
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.
Sep 25, 2019
Hiring and nurturing junior developers
Johnny, Carmen, Jon, and returning guest Stevenson Jean-Pierre talk about hiring engineers with a focus on junior roles. Why do we keep running into these ridiculous job listings that nobody could ever live up to? What benefits do junior developers bring to the team? Why don’t teams put more focus on developing junior engineers? What can we do better?
Sep 20, 2019
Generics in Go
Mat, Johnny, Jon, and special guest Ian Lance Taylor discuss generics in Go. What are generics and why are they useful? Why aren’t interfaces enough? How will the standard library change if generics are added to Go? How has the community contributed to generics? If generics are added, how will this negatively affect the language?
Sep 11, 2019
LIVE from Gophercon UK
LIVE from LondonGophers as part of GopherCon UK! Mat Ryer, and Mark Bates were joined by Liz Rice, Kat Zień, Gautam Rege to talk about the magic in Go’s standard library. Huge thanks to the organizers of LondonGophers and GopherCon UK for making this possible.
Sep 04, 2019
Serverless and Go
Johnny, Mat, Jaana, and special guest Stevenson Jean-Pierre discuss serverless in a Go world. What is serverless, what use cases is serverless good for, what are the trade offs, and how do you program with Go differently in the context of serverless?
Sep 03, 2019
The infrastructure effect: COBOL and Go
We partnered with Red Hat to promote Season 3 of Command Line Heroes — an original podcast from Red Hat, hosted by Saron Yitbarek of CodeNewbie, about the people who transform technology from the command line up. It’s an awesome show and we’re huge fans of Saron and the team behind the podcast, so we wanted to share it with you. Learn more and subscribe at redhat.com/commandlineheroes.
Aug 27, 2019
The importance of representation
Hot off the heels of GopherCon 2019 — Johnny Boursiquot, Jon Calhoun, and special guests Jamal Yusuf, and Yingrong Zhao recap the conference and the importance of representation in the Go community.
Aug 20, 2019
Structuring your Go apps
Jon, Mat, Johnny, and special guest Cory LaNou discuss the ins and outs of structuring Go programs. Why is app structure so important? Why is it hard to structure Go apps? What happens if we get it wrong? Why do we confuse folder structures with application design? How should a new Go app be structured?
Aug 09, 2019
If you've never been to GopherCon...
Jon, Mark, Johnny, and special guest Jamal Yusuf discuss what to expect when attending a conference like GopherCon. What should you be doing before you attend GopherCon? What should you bring to the conference? What shouldn’t you bring? What are the training sessions about? What about the hacking sessions and talking with the Go team? What if you don’t know anyone?
Aug 05, 2019
Go is eating the world of software
It’s The Changelog in the Go Time feed! Adam Stacoviak and Jerod Santo met up with Ron Evans at OSCON on the expo hall floor to talk about Go and how it’s eating the world of software. Specifically they talked about TinyGo and what they’re doing to bring the Go programming language to micro-controllers and modern web browsers. According to Ron Evans, “embedded systems and Go are the most exciting things happening right now.”
Jul 23, 2019
Web development in Go
Mat Ryer, Mark Bates, Johnny Boursiquot, and Aaron Schlesinger discuss web development in Go. Go is great at writing server technology, but how good is it for web development? We’ll talk about HTTP, templating, the front-end, Wasm, and we even discuss Buffalo with its creator, Mark Bates.
Jul 16, 2019
if err != nil
Mat and Carmen along with guest panelists Dave Cheney, Peter Bourgon, and Marcel van Lohuizen discuss errors in Go, including the new try proposal. Many questions get answered…What do we think about how errors work in Go? How is it different from other languages/approaches? What do/don’t we like? What don’t we like? How do we handle errors these days? What’s going on with the try proposal?
Jul 11, 2019
Go tooling
We’re talking about the tools we use every day help us to be productive! This show will be a great introduction for those new to Go tooling, with some discussion around what we think of them after using some of them for many years.
Jul 03, 2019
The art of execution
Panelists Mat Ryer, Johnny Boursiquot, Jon Calhoun, and guest panelist Egon Elbre discuss what they build, why, and how they do it. Everybody has their own unique process for getting things done, so today we’re going to learn about them. Too often processes get in the way and slow things down. How do we look for signs of those slow downs? How do we create a space where people are free to discuss their thoughts and struggles?
Jun 12, 2019
Go 💚 open source
Panelists Mark Bates, Johnny Boursiquot, and Carmen Andoh discuss Go and open source — what is it, the value in contributing, what it means to be a maintainer, best practices, and the recent blog post from Chris Siebenmann titled “Go is Google’s language, not ours.”
Jun 07, 2019
Functional programming?
Panelists Mat Ryer and Johnny Boursiquot are joined by guest panelist Aaron Schlesinger to ask/answer questions like; What is functional programming? Can you do functional programming in Go? Can we apply any learnings from functional programming languages as we write Go code today?
May 29, 2019
Go modules and the Athens project
Panelists Mat Ryer and Carmen Andoh are joined by guest panelists Marwan Sulaiman and Aaron Schlesinger to discuss Go modules and the Athens project.
May 22, 2019
Go for beginners
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.
May 15, 2019
Hardware hacking with TinyGo and Gopherbot
Mat Ryer hosts our first one-on-one interview-style episode with special guest Ron Evans. Mat asks Ron to teach us about Go in IoT, hardware hacking at Gophercon, TinyGo, and Gopherbot.
May 08, 2019
It's time to talk about testing
Is testing an art or a science? What and when should we test? What’s the point of testing and can it go too far? We explore all this and more in this jam-packed episode on testing.
May 02, 2019
Hiring and job interviews
Panelists Mat Ryer, Ashley McNamara, Johnny Boursiquot, and Carmen Andoh discuss the process of getting hired, hiring, and job interviews. If people are the most important part of a team, how do we pick who we work with? What’s the process like? How can it better?
Apr 23, 2019
All about APIs!
Panelists Mat Ryer, Johnny Boursiquot, Jaana B. Dogan, and Mark Bates discuss how humans build machine to machine integrations via APIs — the good, the bad, and the ugly — and how to give yourself the best chance of success.
Apr 16, 2019
Go 2 and the future of Go
We’re back! Panelists Mat Ryer, Johnny Boursiquot, Jaana B. Dogan, and Mark Bates discuss Go 2, the future of Go, what they like and don’t like, and what they would add or remove.
Apr 09, 2019
New Go branding strategy
Steve Francia joined the show and told us EVERYTHING about Go’s new branding strategy (and don’t worry, the gopher isn’t going anywhere!)
May 07, 2018
Hacking drones with Go
Ron Evans joined the show and talked with us about GoCV, Gobot, using Go to control drones, and other interesting projects and news.
Apr 30, 2018
BONUS – Go and WebAssembly (Wasm)
This is a bonus segment in the after show of Go Time #77 with Russ Cox where we talk briefly about WebAssembly (Wasm) support in Go, and how that plays into Go being used as a web language.
Apr 25, 2018
Dependencies and the future of Go
Russ Cox joins us this week to talk about how Russ got involved with Go, Vgo, error handling, updates on Go 2.0, more.
Apr 23, 2018
Building a distributed index with Go
Matt Jaffee joined the show and talked with us about Pilosa, building distributed index with Go, and other interesting projects and news.
Apr 13, 2018
GoLand IDE and managing Gopher Slack
Florin Pățan joined the show and talked with us about GoLand, the pros and cons of using an IDE, his thoughts on the Go community, and managing Gopher Slack.
Apr 06, 2018
Gophercises and creating content for Gophers
Jon Calhoun joined the show and talked with us about Gophercises, experiencing the joy of building cool things, creating content for Gophers, and other interesting projects and news.
Mar 30, 2018
CockroachDB and distributed databases in Go
Andrei Matei joined the show and talked with us about CockroachDB (and why it’s easier to use than any RDBMS), distributed databases with Go, tracing, and other interesting projects and news.
Mar 23, 2018
Learning and teaching Go
Bill Kennedy joined the show and talked with Carlisia about learning Go, teaching Go (which is something we’ll do at some point or another), making good presentations, and other interesting projects and news.
Mar 22, 2018
Go is for everyone
Carmen Andoh joined the show and talked with us about inclusivity, the 2017 Go Developer Survey, visualizing abstractions, and other interesting projects and news.
Mar 22, 2018
From Russia with love
Leo Kalneus joined the show and talked with us about GopherCon Russia and the Go community in Russia. We also debunked a few myths about Siberia and of course talked about interesting Go projects and news.
Mar 16, 2018
Golang Flow, FaaS, and Buffalo
Brian Scott joined the show and talked with us about Golang Flow, contributing to open source, functions as a service, building for the web with Buffalo, and other interesting projects and news.
Mar 09, 2018
SPECIAL — Ask us anything! (pt. 2)
This is another special “Ask Us Anything” episode where we answer more questions submitted by the community. We covered A LOT of ground, including the hardest things we’ve ever written in Go, how the community can drive adoption, what we’d change about Go, and our favorite: “what do gophers eat?”
Mar 01, 2018
Supporting the Go community
Cassandra Salisbury (the Go core team’s newest member) joined Carlisia (who’s hosting all by herself) to talk about getting to know the Go community around the world, organizing meetups, empowering leaders, and what’s in store for the future.
Feb 23, 2018
Performance, fuzzing & magic
Damian Gryski joined the show and talked with us about perfbook, performance profiling, reading white papers for fun, fuzzing, and other interesting projects and news.
Feb 16, 2018
GopherCon Brazil & Genetics
Vitor De Mario joined the show and talked with us about hacking genetics with Go, GopherCon Brazil, machine learning, and other interesting projects and news.
Feb 06, 2018
InfluxDB & IoT Data
Paul Dix joined the show and talked with us about InfluxDB, building a company with OSS, improving the language, and other interesting projects and news.
Jan 29, 2018
Changelog Takeover — K8s and Virtual Kubelet
Adam and Jerod jumped in as hosts for an experiment in quantum podcasting, letting Erik and Brian play guests to talk about Virtual Kubelet, building OSS at Microsoft, BBQ (of course), and other interesting projects and news.
Jan 15, 2018
Building Blocks
Jeff Lindsay joined the show to talk about workflow automation, designing apis, and building the society we want to live in…plus a surprise special announcement!
Dec 01, 2017
Loggregator, gRPC, Diodes
Jason Keene and Andrew Poydence joined the show to talk about Loggregator, scaling with Go at Pivotal, Diodes, and other interesting Go projects and news.
Nov 25, 2017
Why WADL When You Can Swagger?
Ivan Porto Carrero joined the show to talk about generating documentation (with Swagger), pks, kubo, and other interesting Go projects and news.
Nov 17, 2017
Improved Improved Improved (i3)
Michael Stapelberg joined the show to talk about window management, open sourcing infrastructure, error handling, and other interesting Go projects and news.
Nov 10, 2017
Full-time Open Source
Dmitri Shuralyov joined the show to talk about being a full time contributor to open source, developing developer tools, and other interesting Go projects and news.
Nov 03, 2017
Presenting a Pragmatic Perspective
Cindy Sridharan joined the show to talk about development and operations as a generalist, leveling up as an engineer (while still providing business value), challenging the status-quo, and other interesting Go projects and news.
Sep 15, 2017
Container Security and Demystifying Complexity
Liz Rice joined the show to talk about containers, cloud security, making complex concepts easier to understand, and other interesting Go projects and news.
Sep 08, 2017
Dep, Cross-platform, and Getting Started
Carolyn Van Slyck joined the show to talk about dependency management, upping your cross-platform game, getting into Go, and other interesting Go projects and news.
Aug 31, 2017
Go at Walmart (and Scale)
Chase Adams joined the show to talk about working on distributed systems with distributed teams, giving people opportunities to learn and grow, and other interesting Go projects and news.
Aug 18, 2017
GopherCon 2017: A Retrospective
After taking some time to recover, the gang rehashes all the greatest talks and favorite moments from this year’s GopherCon. Much love to the Go community and all the souls who worked tirelessly to make this conference happen.
Aug 18, 2017
All About The Go Compiler
David Chase joined the show for a technical Q & A on compilers and what makes Go’s compiler different from the rest (and of course, other interesting Go projects and news)
Aug 07, 2017
Infosec research and app security
Aaron Hnatiw joined the show to talk about being a security researcher, teaching application security with Go, and a deep dive on how engineers and developers can get started with infosec. Plus: white hat, black hat, red team, blue team…Aaron sorts it all out for us.
Jul 19, 2017
Bringing Kubernetes to Azure
Kris Nova joined the show to talk about developer empathy, running K8s on Azure, Kops, Draft, editors, containerizing odd things…and what it’s like to play a keytar.
Jul 06, 2017
Adventures in VS Code
Ramya Achutha Rao joined the show to talk about all the things that make VS Code a great editor for writing Go, getting help from the community, plus other interesting Go projects and news.
Jun 13, 2017
Restic and backups (done right)
Alexander Neumann joined the show to talk about using Go to write backup software, solving tough problems like deduplication, scratching your own itch, and other interesting Go projects and news.
Jun 01, 2017
Docker, Moby, Containers
Solomon Hykes joined the show to talk about all things Docker, Moby Project, and what makes Go a good fit for container management.
May 25, 2017
Periph.io, Drivers, Hardware
Marc-Antoine Ruel joined the show for a deep dive on controlling hardware, writing drivers with Go, and other interesting Go projects and news.
May 12, 2017
SPECIAL — Ask Us Anything!
This is a special “Ask Us Anything” episode where we answered questions submitted by the community — covering everything from impostor syndrome and the future of Go, to the music we listen to to get in a groove, and barbecue (of course).
May 04, 2017
Go4 and Contributing to Go
Brad Fitzpatrick joined the show to talk about becoming the face of open source Go, getting the community involved in bug triage, the potential future of Go, and other interesting Go projects and news.
Apr 27, 2017
Getting Better, Mentoring, Drawing Gophers
Ashley McNamara joined the show to talk about sharing developer experiences, seeking help from the community, getting people excited about STEM, and other interesting Go projects and news.
Apr 20, 2017
Race detection, firmware, production-grade Go
Kavya Joshi joined the show to talk about shipping production-grade Go, writing firmware with Go, making complex technical concepts accessible, and other interesting Go projects and news.
Apr 13, 2017
Distributed Messaging and Network Clients
Wally Quevedo joined the show to talk processing millions of messages per second with Go, writing network clients, performance at scale, and other interesting Go projects and news.
Apr 06, 2017
Game Development and Rebuilding Microservices
Luna Duclos joined the show to talk about rebuilding a microservice infrastructure with Go, game development, and other interesting Go projects and news.
Mar 31, 2017
Splice, Audio, Compassion
Matt Aimonetti joined the show to talk about using go to solve tough audio problems, making go for everyone, empowering people with software, and other interesting Go projects and news.
Mar 24, 2017
Go Developer Survey
Steve Francia joined the show to talk about the results of the 2016 Go Developer Survey and other interesting Go projects and news.
Mar 16, 2017
Gobot, Hardware, Gatekeeping
Ron Evans joined the show to talk about Gobot, writing software for hardware, and open source software’s role in improving the human condition.
Mar 09, 2017
Dependency Management, Semver, Community Consensus
Sam Boyer joined the show to talk about dependency management, building community consensus, and other interesting Go projects and news.
Mar 02, 2017
Honeycomb, Complex Systems, Saving Sanity
Charity Majors joined the show to talk about debugging complex systems, using go to save one’s sanity, hiring smart people who can learn, and collectively working to make “on-call” life not miserable.
Feb 23, 2017
Pachyderm, Provenance, Data Lakes
Joe Doliner joined the show to talk about managing data lakes with Pachyderm, data containers, provenance, and other interesting Go projects and news.
Feb 16, 2017
Gopherize.me, GitHub Stars, BitBar
Mat Ryer joined the show to talk about creating your own Gopher avatar with Gopherize.me, the importance of GitHub Stars, his project BitBar, and other interesting Go projects and news. Special thanks to Kelsey Hightower for guest hosting too!
Feb 09, 2017
Hellogopher, whosthere?
Filippo Valsorda joined the show to talk about his project Hellogopher, whosthere (whoami.filippo.io), $GOPATH, TLS 1.3, Cloudflare’s secret reverse proxy, and more.
Feb 02, 2017
Go, Jocko, Kafka
Travis Jeffery joined the show to talk about Go, Jocko, Kafka, how Kafka’s storage internals work, and interesting Go projects and news.
Jan 26, 2017
Discussing Imposter Syndrome
Johnny Boursiquot and Bill Kennedy joined the show with Erik and Carlisia to talk about a hard subject — Imposter Syndrome. Not often enough do we get to have open conversations about the eventual inadequacies we all face at some point in our career; some more often than others. You are !imposter.
Jan 19, 2017
Go and Buffalo Live from Dunkin' Donuts
Mark Bates joined the show this week live from his local Dunkin’ Donuts to talk about Go and Buffalo — his Go web framework. Those who listened live said this was our best show yet. If you agree let us know in #gotimefm on Gopher Slack or say hi on Twitter.
Jan 12, 2017
Creating a programming language
Thorsten Ball joined the show to talk about creating a programming language, writing an interpreter, why he wrote the book “Writing An Interpreter in Go”, how writing a language/interpreter will help you better understand other programming languages, building a computer from Nand to Tetris, and his thoughts on imposter syndrome.
Dec 23, 2016
The Go Compiler and Go 1.8
Keith Randall from the Go team joined the show to talk about why a new compiler, what we gain from SSA, what’s next for the compiler, Go 1.8, and the goals/plans for Go 1.9.
Dec 15, 2016
Teaching and Learning Go
Todd McLeod joined the show to talk about teaching and learning Go, his work as an Instructor at Fresno City College, Udemy and on YouTube.
Dec 14, 2016
Go Kit, Dependency Management, Microservices
Peter Bourgon joined the show to talk about Go kit, microservices, Go in the enterprise, dependency management, and writing Go packages.
Dec 13, 2016
Juju, Jujucharms, Gorram
Nate Finch joined the show this week to talk about Juju, Charms, maturing a project along side Go, Gorram, finding your happy path, and more.
Nov 10, 2016
Open Sourcing Chain's Developer Platform
Tess Rinearson joined the show to talk about Chain launching their open source developer platform, choosing an open source license, open sourcing Chain Core, and the future of this powerful blockchain written in Go.
Nov 03, 2016
Go work groups and hardware projects
Jaana B. Dogan joined the show to talk about hardware geekery, on-boarding people into Go, the state of the feedback loop with the Go team, and her initiative to create Go Work Groups.
Oct 27, 2016
Building a startup on Go
Blake Mizerany joined the show to talk about coming to Go from Ruby, Go’s growth and adoption over the past 7 years, adopting external dependencies, building a startup on Go, and coding as CEO.
Oct 20, 2016
Kubernetes, Containers, Go
Kelsey Hightower joined the show to talk about the work he’s doing at Google Cloud Platform, Kubernetes, Bringing Pokémon GO to life on Google Cloud, Kubernetes cluster federation, Containers, and of course Go.
Oct 13, 2016
Programming Practices, Exercism, Open Source
Katrina Owen joined the show to explore ideas about open source, code review, learning to program, becoming a savvy programmer, mentoring, projects she’s working on, and also her very prominent and amazing code learning tool Exercism.
Oct 06, 2016
Go in 5 Minutes & design patterns
Aaron Schlesinger joined the show this week to talk about his Go in 5 Minutes series of screencasts, and design patterns in Go.
Sep 22, 2016
Monorepos, Mentoring, Testing
Bryan Lyles joined the show to talk about career progression in tech and learning, the idea of a 10x developer, the practice of testing, and advantages and disadvantages of a monorepo.
Sep 15, 2016
SOLID Go Design
Dave Cheney joined the show this week to discuss SOLID Go design, software design in Go, what it means to write “good Go code”, and error handling.
Sep 08, 2016
The Go Standard Library
Ben Johnson, creator of BoltDB, joined the show to talk about NoSQL vs. Sql databases, tradeoffs between the two, and choosing one over the other. We also talk about Ben’s Secret Lives of Data project, visualizing data structures, and go over his motivation and plans for his blog post series “Go Walkthrough” of the Go standard library.
Sep 01, 2016
Matt Holt on CaddyServer, the ACME Protocol, TLS
This episode wins the contest for the most protocols discussed. Matt Holt joined the show to to talk about TLS, Let’s Encrypt, the ACME protocol, CaddyServer, and a host of other important information security issues.
Aug 25, 2016
Francesc Campoy on GopherCon and understanding nil
In our first show after GopherCon, we are joined by Francesc Campoy to chat about some of our GopherCon experience, understanding nil, and a great variety of interesting topics of interest to the Go community.
Aug 18, 2016
Beyang Liu on Go at Sourcegraph and Writing Better Code
Beyang Liu from Sourcegraph joins the show to talk about Go at Sourcegraph and their code insight and language analysis tools for writing better code. We also get an understanding of what Sourcegraph is and the many ways to integrate it into your workflow.
Aug 10, 2016
Jessie Frazelle on Maintaining Open Source, Docker, dotfiles
Jessie Frazelle joins us this week to talk about being an open source maintainer, Docker’s pull request acceptance workflow, dotfiles, getting started with public speaking.
Aug 10, 2016
State of Go Survey and Go at Heroku
Ed Muller from Heroku join us to discuss his State of Go survey, vendoring and versioning, the Heroku Go Buildpack, how they use Go at Heroku, and more.
Aug 01, 2016
Scott Mansfield on Go at Netflix
Scott Mansfield joins us this week to talk about Go at Netflix, performance, latency and caching, Rend (their memcached proxy), chaos monkey, and more.
Jul 28, 2016
Asim Aslam on Micro, the Go Microservice Toolkit
Asim Aslam joined us to talk about Micro, a pluggable RPC based library which provides the fundamental building blocks for writing microservices in Go. We also discussed open source sustainability, microservices, and serverless architecture.
Jul 27, 2016
Raphaël Simon on goa, the Framework for Building Microservices
A deep dive into goa, a design-based microservice framework with a DSL that generates idiomatic Go code for your APIs, swagger documentation, and tests helpers.
Jul 26, 2016
Bill Kennedy on Mechanical Sympathy
A deep dive into the fascinating topic of mechanical sympathy with Bill Kennedy. We talk about that plus CPU caches, how object oriented programming is not oriented to be sympathetic to the hardware, and data-oriented design.
Jun 23, 2016
Sarah Adams on Test2Doc and Women Who Go
On this show we’re joined by Sarah Adams. We talk about creating safe spaces for women to get started in the Go community, about Women Who Go, and take a deep dive into her Test2Doc open source project.
Jun 21, 2016
Go and Data Science
In this super informative show with Daniel Whitenack we discuss Go and data science. We talk about what data science really is, tools and projects for getting started with data science using Go, and what to expect from Daniel’s talk at GopherCon this year titled “Go for Data Science”.
Jun 16, 2016
Early Go Adoption
Travis Reeder joins the show today to talk about Iron.io, early Go adoption, how Iron.io helps with GoSF and other events for the Go community, the implications of containers at scale, and more.
Jun 10, 2016
Go Community Discussions
Cory LaNou is our guest this week. He shared what it was like to start open source development after 13 years of programming behind closed doors, and what it was like to have one of his first contributions (a bug fix) be reviewed by Dave Cheney (a very prominent Go developer). Cory helps to organize several local meetups and shared the details of his work in the community, as well as some inspiring tips for how to get involved. We also discussed the need for domain knowledge to understand the code you’re reading, microservices and frameworks in Go, reasoning for breaking down an application, performance, and more.
Jun 02, 2016
It's Go Time!
In this inaugural show Erik, Brian, and Carlisia kick things off by sharing some recent Go news that caught their attention, what to expect from this show, ways to get in touch, and more.
May 19, 2016