Your source for wide-ranging discussions from all around the Go community. 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.
Mat gathers the entire cast (sans Natalie, sadly) alongside our producer, Jerod Santo, for one last Go Time. That's right, this is Go Time's finale episode. After eight years and 340 episodes, we are going out on top. Join us one last time, you won't regret it!
We share our feelings, reminisce on the good times, list some of our favorite moments & share a few opinions, which may (or may not) be unpopular. đ
With so many great programming languages having emerged in the last decade, many of them purpose-built, when and where does Go still make sense and how do you make the case for it at work?
With the number of libraries available to Go developers these days, you'd think building a CLI app was now a trivial matter. But like many things in software development, it depends. In this episode, we explore the challenges that arose during one team's journey towards a production-ready CLI.
Writing a shell is rarely the kind of project you take on lightly. In this episode, Johnny is joined by Qi Xiao to explore how to go about such a feat in Go.
Yasir Ekinci joins Johnny & Mat to talk about how virtually every Observability vendor is rushing to add Generative AI capabilities to their products and what that entails from both a development and usability perspective.
The last time we did a roundup of our unpopular opinion polls, it was November of 2021!
That's too long ago, so today we fix that bug. Join Go Time producer, Jerod Santo, as he ranks & reviews the most (un)popular opinions of 2022.
In this episode, we will be talking to Russ Cox, who joined the Go team at Google in 2008 and has been the Go project tech lead since 2012, about stepping back & handing over the reins to Austin Clements, who will also join us! We also have Cherry Mui, who is stepping into Austin's previous role as tech lead of the âGo coreâ.
Tech twitter ("tech X"?) is abuzz with Paul Graham's Founder Mode essay. How does that affect you or come into play when you're not a founder? Does it matter at all to you, your projects & your code?
In this follow-up to episode #306, "How soon until AI takes my job?", the gang of (grumpy?) veteran software engineers candidly chat about how their day to day is changing in the midst of improving AI tooling & hype.
Join Johnny as he dives into the world of home automation with Ricardo Gerardi & Mike Riley, two tinkerers who've taken the plunge with Go. We explore the challenges (and the fun) they encounter along the way. If you're interested in automating your home (or working with micro controllers) come learn how to get started!
On this episode, Angelica is joined by Go community leaders from around the world: meetup organizers from Guadalajara, St. Louis, New York & Go Bridge Atlanta. Together, they explore the ins & outs of organizing meetups, the benefits of attending, the Go Developer Network (GDN) & the current state of the Go Meetup community.
This episode focuses on the art of delivering concise Lightning Talks, a popular format at conferences worldwide where speakers present in a short timeframe. Joined by some of this year's GopherCon Lightning Talkers, we'll discuss their experiences, challenges & tips for effective communication within a limited time.
Kris, Angelica & Johnny react to the recently announced Go team changes, discuss the finding that 80% of developers surveyed by Stack Overflow are unhappy & disagree about the concept of tech debt (but agree that something's gotta give).
We're talking OpenAPI this week! Kris & Johnny are joined by Jamie Tanna, one of the maintainers of oapi-codegen, to discuss OpenAPI, API design philosophies, versioning, and open source maintenance and sustainability. In addition to the usual laughs and unpopular opinions, this week's episode includes a Changelog++ section that you don't want to miss.
JesĂșs Espino from Mattermost tells Natalie all about (the final four of) his 10 âaha momentsâ he had reading the Go source code. Don't miss Part 1!
JesĂșs Espino from Mattermost tells Natalie all about (the first six of) his 10 "aha moments" he had reading the Go source code. Part 2 (with the rest of his aha moments) coming soon!
Mat Ryer has been writing HTTP services in Go for more than 13 years. Needless to say, he's learned a lot along the way. Today, Johnny & Ian sit down with Mat to ask him all about it.
Dependencies! We need them, but how do we use them effectively and safely? In this week's episode Kris is joined by Ian and Johnny to discuss the polyfill.io supply chain attack, the history of dependency management and usage in Go, and the Go Proverb that "a little copying is better than a little dependency". Of course, we wrap up the episode with some Unpopular Opinions!
Our award winning worthy survey game show is back, this time Mat Ryer hosts it live on stage at GopherCon EU Berlin 2024! Join in & play along as we see which team can better guess what these GopherCon gophers had to say!
This week we're catching up on the news! Kris is joined by Ian to discuss some of the recent news from around the Go community. Listen in to hear whether the co-hosts believe there's software that shouldn't be written in Go, their thoughts on if Go is evolving in the right direction & whether common nouns make good package names.
Angelica is joined by Cameron Balahan, Sameer Ajmani & Russ Cox from the Go Team at Google to talk about how things get done on the Go Team, how do they decide what to improve and then how do they go about improving it. We also discuss how they decide what to work when & what the future of Go might look like.
Angelica is joined by Samantha Coyle to talk about her newly published textbook: Go Programming - From Beginner to Professional. This book serves as a go-to guide to master Go for real-world software dev success covering fundamentals to advanced topics.
In this week's episode we're talking about the news! In this laugh-filled episode, Kris is joined by Ian & Johnny to discuss the future of Go, both the Go team itself and iterations of packages within the standard library; Microsoft creating a Go blog & a Go fork; and SQLite and Go.
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.
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!
Our âwhatâs new in Goâ correspondent Carl Johnson joins Johnny & Kris yet again to discuss whatâs new with the latest iteration of Go in version 1.21.
Today weâre talking with Alice Merrick & Andy Walker about building a world-class developer experience. You know it when you see it, things just feel right. But itâs more than just a pleasant UI or lipstick on a pig (which is a saying), it really matters.
So, do we like generics or not? Some people feared they'd be the end of the language. Others were very hopeful, and had clear use cases, and were thrilled about the feature coming to the language. It was also often touted as the reason a lot of people didn't adopt Go. So what do we think now? Mat and Kris are joined by Roger Peppe and Bryan Boreham to discuss the state of Generics in Go.
The Go ecosystem has a hoard of tools and editors for Gophers to choose from and it can be difficult to find ones that are a good fit for each individual. In this episode, we discuss what tools and editors we're using, the ones we wish existed, how we go about finding new ones, and why we sometimes choose to write our own tools.
Our award winning worthy survey game show is back, this time Mat Ryer hosts it live on stage at GopherCon Europe 2023!
Elena Grahovac joins forces with Björn Rabenstein to battle it out with Alice Merrick & Mohammed S. Al Sahaf. Let's see who can better guess what the GopherCon Europe gophers had to say!
Many Gophers build projects as a team of one. Sometimes these are side projects, other times they are projects used by millions of people but who are still maintained by a single individual. In this episode, the panel discusses techniques for developing and maintaining Go projects as a solo developer.
Listener Joe Davidson recently tweeted: "Iâd really be interested in an episode debating Kubernetes vs serverless functions for distributed systems. As someone working a lot with serverless to create large scale systems, for me the complexity in Kubernetes doesnât seem worth it, especially when onboarding new people. But Iâd like to see it from the other perspectives. I could be missing something."
So we invited Joe on the show alongside Abdel Sghiouar and Srdjan Petrovic to discuss!
Kaylyn Gibilterra returns as Natalie & the gang take our diversity conversation one step further. This time we're talking about neurodiversity as it relates to being a developer, a manager, a conference participant & more.
Our guests helped create a ML pipeline that enabled image processing and automated image comparisons, enabling healthcare use cases through their series of microservices that automatically detect, manage, and process images received from OEM equipment.
In this episode they will chat through the challenges and how they overcame them, focusing specifically on the wait strategy for their ML Pipeline Healthcare Solution microservices. We'll also touch on how improvements were made to an open source Go package as part of this project.
Tips, tricks, best practices and philosophical AI debates abound when OpenAI ambassador Bram Adams joins Natalie, Johnny & Mat to discuss prompt engineering.
Return guests Ben Johnson & Chris James join Mat & Kris to talk about the files and folders of your Go projects, big and small. Does the holy grail exist, of the perfect structure to rule them all? Or are we doomed to be figuring this out for the rest of our lives?
Conferences are an integral part of the Go community, but the experience of conferences has remained the same even as the value propositions change. In this episode we discuss what conferences generally provide, how value propositions have changed, and what changes conference organizers could make to realign their conference experience to a new set of value propositions.
The DevCycle team joins Jon & Kris for a deep conversation on WebAssembly (Wasm) and Go! After a high-level discussion of what Wasm is all about, we learn how they're using it in production in cool and interesting ways. We finish up with a spicy unpop segment featuring buzzwords like "ChatGPT", "LLM", "NFT" and "AGI"
Go conferences are not as diverse as we'd like them to be. There are initiatives in place to improve this situation. Among other roles, Ronna Steinberg is the Head of Diversity at GopherCon Europe. In this episode we'll learn more about the goal, the process and the problems, and how can each one of us help make this better.
Mat & Johnny interview everyone's favorite LLM (Natalie with a special hat on) to see if it'd make a good hire as a Go dev. Also, Mat tries to turn it into his very own creepy robot by asking personal questions about his co-hosts. Things get weird. In a good way?
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?
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!
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...
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.
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.
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?
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.
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.
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*.
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...
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...
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.
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.
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!
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.
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.
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?
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)!
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!
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?
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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?
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...
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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?
On this episode, Michael Matloob and Daniel MartĂ pinky promise not to talk about Go 1.18's two big features (fuzzing and generics). Instead, we're focusing in on the *other* cool stuff that's new!
Natalie 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.
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?
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.
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?
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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."
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
The ultimate guide to crafting your GopherCon proposal
Thu, 15 Apr 2021
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.
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.
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.
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.
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.
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. đ€
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.
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_?!?!
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.
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!
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.
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!
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?
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.
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!
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.
Play with Go
Thu, 03 Dec 2020
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!
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!
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.
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.
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.
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?"
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.
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?"
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?"
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? đ
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?"
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!
FĂŒĆșĆŸÄŻĂ±g
Thu, 03 Sep 2020
A deep dive on Fuzzing and a close look at the official Fuzzing proposal for Go.
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).
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!
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.
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?
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.
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?
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?
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.
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.
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?
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.
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.
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.
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).
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?
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?
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).
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.
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?
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.
Pow! Pow! Power tools!
Thu, 12 Mar 2020
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.
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?
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.
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.
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.
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!
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?
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.
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.
Go at Cloudflare
Tue, 14 Jan 2020
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?
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?
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?
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.
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. đ
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.
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."
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.
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.
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.
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?
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.
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?
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.
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?
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?
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.
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?
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.
The importance of representation
Tue, 20 Aug 2019
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.
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?
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?
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."
Web development in Go
Tue, 16 Jul 2019
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.
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?
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.
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?
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."
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?
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.
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.
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.
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?
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.
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.
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.
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.
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.
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.
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.
Carmen Andoh joined the show and talked with us about inclusivity, the 2017 Go Developer Survey, visualizing abstractions, and other interesting projects and news.
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.
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.
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?â
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.
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.
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.
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.
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.
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!
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.
Michael Stapelberg joined the show to talk about window management, open sourcing infrastructure, error handling, and other interesting Go projects and news.
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.
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.
Liz Rice joined the show to talk about containers, cloud security, making complex concepts easier to understand, and other interesting Go projects and news.
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.
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.
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.
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)
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.
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.
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.
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.
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).
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.
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.
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.
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.
Luna Duclos joined the show to talk about rebuilding a microservice infrastructure with Go, game development, and other interesting Go projects and news.
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.
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.
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!
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.
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`.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Francesc Campoy on GopherCon and understanding nil
Thu, 18 Aug 2016
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.
Beyang Liu on Go at Sourcegraph and Writing Better Code
Wed, 10 Aug 2016
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.
Jessie Frazelle on Maintaining Open Source, Docker, dotfiles
Wed, 10 Aug 2016
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.
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.
Scott Mansfield joins us this week to talk about Go at Netflix, performance, latency and caching, Rend (their memcached proxy), chaos monkey, and more.
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.
Raphaël Simon on goa, the Framework for Building Microservices
Tue, 26 Jul 2016
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.
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.
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.
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â.
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.
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.
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.
