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.
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?
Jaana Dogan started with a draft and this tweet and ended up laying down some serious knowledge on databases.
A large majority of computer systems have some state and are likely to depend on a storage system. My knowledge on databases accumulated over time, but along the way our design mistakes caused data loss and outages. In data-heavy systems, databases are at the core of system design goals and tradeoffs. Even though it is impossible to ignore how databases work, the problems that application developers foresee and experience will often be just the tip of the iceberg.
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?
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.
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?
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.
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.
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?
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.
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?
Have you ever launched a new service to production? Have you ever been maintaining a production service? If you answer “yes” to one of these questions, have you been guided during the process? What’s good or bad to do in production? And how do you transfer knowledge when new team members want to release production services or take the ownership of existing services?
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.
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, 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.
What is latency? And how exactly do you debug it?
Jaana writes on the Observability+ blog:
In the recent decade, our systems got complex. Our average production environments consist of many different services (many microservices, storage systems and more) with different deployment and production-maintenance cycles.
Measuring latency and being able to react to latency issues are getting equally complex as our systems got more complex. This article will help you how to navigate yourself at a latency problem and what you need to put in place to effectively do so.