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!
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).
Francesc Campoy and Isobel Redelmeier joins the panel to discuss Go’s context package including real-world insights into its use and misuse.
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!
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 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.
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.
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.
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).
Bryan Liles joins Johnny and Mat for a wide-ranging discussion that starts with the question: what even is enterprise Go?
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?
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?