What's coming beyond Go 1.24? A look at proposals, and interview with Anton Zhiyanov

This show is supported by you. Stick around till the ad break to hear more about that and other exciting things. This is CuppaGo for Jan. 31, 2025. Keep up to date with the important happenings in the Go community in about fifteen minutes per week. I'm Shay Nehmad. I'm Jonathan Hall. And our first interview for 2025 is up. Yay. We have a pretty cool show, a lot of proposals to chew through, and an interview with Anton of the the famous interactive release notes.

We already did the interview.

We did. How have you been?

I'm pretty good. We're, buying a house in three weeks. We just finished the inspection and all that stuff, asked for a little bit of extra money to help replace the roof. The buyers agreed. So we're doing well.

Replace the roof.

Yeah. It's got an old roof. Buyers are gonna help pay the sellers are gonna help pay for for half of the roof replacement.

Nice. So are like are you replacing half the roof or replacing the entire roof?

We'll replace the bottom half.

That's the important part.

Yeah. I want to put some solar panels on, pretty soon. So, we want to get the roof replaced first, of course.

Nice. That sounds prudent. I just placed a ton of solar panels on my factorial planet, and these work pretty well. They're very important, especially in Gleeba.

Maybe I should have you come put some on my planet, on my house.

I don't know. Maybe.

Well, we're gonna be talking about a lot of proposals, which excites me because I love proposals. It's 1 of my favorite parts of the show. I don't know. I I I like the forward looking into the future telling what what full things Go is gonna have later on.

Yeah. What what later on, we'll discuss what excites you about modern Go. Yes. Let's talk about runtime trace flight recording. Yeah. Just the name of that proposal sounds good.

It does. It sounds really, I don't know, high-tech or something. So the Java developers among us are probably already familiar with, Java's flight recorder, capabilities. Go is gonna be getting something similar.

What is a flight recorder?

Yeah. What is a flight recorder? So this proposal is a little bit old. It's not that old. It's almost two years old. So, the idea is sometimes something interesting happens in your program. By interesting, I mean, like, something probably unexpected. Could be a bug or just unexpected behavior, and you wanna maybe debug that. So you want to do some sort of tracing to see, you know, what what was happening. Pretty expensive to have tracing on all the time.

I need it. What what sort of information does it write? Like, okay. So it's a circle of buffer, but it's a circle of buffer of of what?

Yeah. That's a good question. What kind of data will it give you? It's gonna give you basically the same sort of information you can already get with Go's, tracing support. So, how long it spends in particular Go routines or on certain functions, how many memory allocations, things like that. The the the main thing is that you don't have to run it in like a you don't have to capture all the data from your tracing to get what's valuable, because of the circular buffer.

So I wonder I just integrated Sentry into a back end just like this week. Mhmm. Wondering if this is good for, like, observability companies, if it's bad for observability companies? Because if if you can do flight recording, what's the point of, like, buying Sentry or or Surajit tools?

I think it's good. And I'll refer back to I think it was the interview I did with John Bodnar. I think he missed that interview, the author of, 1 of the Go books that, that I like. And he was really excited about some of this. I don't know if it was this specific proposal, but he was really excited about some of the real time tracing that Go was hoping to add because it could it make it easier to export some of that data to services like Sentry or Datadog and and things like that.

Yeah. That that makes sense. Like, integrated with the rest of their features and whatever. Yeah. Generally, flight recording seems like a super useful technique.

So I think you could decide when to trigger it. I think you just get to call the right to when when you want the data. So it's up to you to instrument that.

So you should have, like, a recover thing on top of all of your web server anyway. Right? Because you don't wanna panic to crash your web server. Yeah. And then in that recovery, you should also call to write to other than doing the rest of your cleanups. Cool. Cool. Cool. Yep. Seems very useful, and it's been, like, waiting for a long time, and now it's been moved to approved.

Yay.

If you wanna implement it. And at least from the comments here, it looks like they're missing some user experience. Maybe trying to use whatever, like, to change list they have ready could be useful for this, proposal. So it's a very interesting proposal, and it's been accepted. You wanted to take a look at another accepted 1.

Yeah. Speaking of, waiting for cool things to happen, why don't you tell us about this next 1? Okay. As soon as I tell you to go.

Oh, no. I get it. Yeah. It's a proposal from 2016, which is incredible. It's I think what's happening here, and we might, like, only see it now, because there's been, like, a change of the guard in in the proposal ownership. Right? It was Russ, and now it's Austin. They might be doing, like, a backlog cleanup, sort of thing, going through great proposals from the past. This 1 is I'm I'm not sure I 100% understand it, and it sounds from your joke that you do.

I think I do. So Yes.

The the it's a race condition, right, with weight groups.

Yeah. It's it's a misuse that, of sync weight group that leads to a race condition.

Okay. So let's assume I don't have to understand the specific race condition. What's this proposal about? Like, okay, I can write code that does race conditions even in Go.

So the the this is about sync wait group, and the the proposal isn't to change sync wait group. It's to add a vet check for 1 particular misuse of sync wait group. So if you've used sync wait group, I think it'll make sense to explain this over over audio. You you create a sync wait group, and then you call assuming your wait group is called w g, you call w g add, typically, w g add 1 for every goroutine you're gonna start and then wait for. The common misuse is to call that w g add within the goroutine.

The the main thing that surprised me here in the proposal is that it's not detectable by the race detector. Like, why wouldn't it be detected by the race detector? Isn't isn't that the whole point of the race detector?

The race detector specifically detects, data races, and this is not actually a data race. This is a case of a process finishing before a go routine has has started. So it's a different it's a different kind of race.

The interesting thing, like, this is a pretty old proposal. There's a lot of discussion here. 1 thing I like is, how, it's planning to get resolved. Right? It's not a side of, proposals we discuss a lot, like the implementation.

Yeah. Indeed.

Or or do you think, like, implementing this without, like, parsing the AST and actually trying to figure out what's the path, etcetera, etcetera, all the crazy heuristics? Do you like, do you think it's a good idea or not?

I think it's a good idea. I I I think I I I can think of some cases where maybe if you have Go routines calling Go routines or you're you're doing something weird, you might not catch it. But I don't think that would be a false negative. I don't think you're gonna get false positives very I I can't imagine how you would with with a simple check like this. So I I think it's a good a good thing to add.

The the most fun part is, Alan Donovan, posting the static check analyzer and finding, 57 matches, all of which are true positives for this case from, like, real projects, like Caddy, Go2Byte, and OmniScale, and, like, just real life projects that have this, mistake. So I think that's the strongest argument out of any, like, squabbling you can do in the comments. Hey, I found 57 people who did this wrong exactly in the same way. We should add the linter rule. Although, go go vet is is, like, stronger than a linter rule

Yeah.

Because it comes shipped with the with the Go tool. It's almost as strong as a compiler error. Almost.

Yeah. And and I'll point out that originally, this proposal was to add to change the API or to add to the API of the wait group, type itself. People didn't like that. So it's it's but they they did like the idea of of adding a a go back rule. And I think I agree the go back rules won't be the way to go.

Yeah. Also, they suggested the API wasn't that great anyway. It was very confusing, at least for me.

Although, if you want the the API that he suggested is basically the same API as the, air group has in the x air group package. So if you want that API, you can just use that instead. Cool. Cool.

Cool. So that has been accepted. And with the simple implementation, we we should probably see that in 01/25 as well.

I think so.

Maybe even back ported. Like, why not?

That would be fancy. Cool. 1 other proposal, I wanna talk about. It's not actually a proposal yet. It's not tech I guess it's a it's still in discussion phase, but we we've talked about it before.

Yeah. I'm literally seeing, like, I refreshed the page. I'm seeing Daniel Marti, which we also had on commenting on this right now, like, forty minutes ago commented on. And just looking at his comments, I I picked something interesting from this. By the way, like, a 50 lines of of proposal, detailed APIs, etcetera, etcetera. This is like a proper RFC document, that you can print in order to sleep on. So, 1 interesting thing about the proposed implementation is to do it in x slash JSON

Mhmm.

Module and not just in JSON v 2 in the standard library. Users who are using older versions of Go can still use the v 2. Yeah. And I like that. It will use type aliases to the Go standard library, so you should be you should be good other way.

Right? Yep. And to be clear, this will be a clone. The go golang.org/x/json will be a clone of the standard library, not an alternative too. So you'll have both options.

Yeah. For sure. So what's the general like, why do I need a JSON v 2? What's wrong with JSON? Just in general.

So I think the most compelling argument for JSON v 2 is it will be much faster. Fewer memory allocations. The the in in my opinion, the biggest weakness of the current, JSON implementation is although it appears to work on byte streams, you know, there's an encoder and decoder that takes an IO reader or uses IO writer, It actually reads in the entire buffer before it starts, iterating through it. So you can't just send it to 2 terabytes of JSON and expect it to do the right thing. It's gonna read that into memory before it starts doing stuff.

Cool. This sounds like a good, like, big project to join, like, if you wanted to right? Like, a deep project. If you if you're taking a year sabbatical in between startups or something, you plan to develop a terminal emulator, but Ghosty has already done that, doing the JSON v 2 for Go sounds like a great project to join into. Alright. That does it for proposals. Let's do a quick lightning round.

Let's do it.

Lightning round. Jonathan.

Try.

We just had, problems with, weight groups. Right? But channels can also be confusing. Closing channels, working with buffer channels, limiting the number of work of workers, not using nil channels. Confusing stuff. Right?

Yeah. I agree. Channels can be confusing.

Don't you worry. Anton Zhivanov, has, his new chapter of his book, The Gist of Go, channels out. And if that name, rings a bell, a, it's because he's on the, probably, the name of this episode. And, 2, because he's the interactive release notes guy. And his book is also filled with interactive examples.

Well, I wanna call out, an article from 1 of our listeners, and he's been on the show before too, Jamie Tanna, who wrote, a little short blog post called Go 1.20 Go tool is 1 of the best additions to the ecosystem in years. It made it around on all the cool places on Hacker News and Reddit, I suppose. It got a little bit of blowback. We'll put links to some of that too. But it's still I think it's a nice overview of this new tool called tool, the the tool tool.

I I think it makes a lot of sense, or I should say it another way. Any other language I use has, dev dependencies. Right? And I developed in Python, so Poetry or UV have the dev dependencies section. And when you program in Node, you have minus minus save dev whenever you install a thing.

Mhmm.

I had a friend who worked at Google, and he said that's how it works. So I'm just basing my it's, like, secondhand. I might be wrong. It's very clearly missing, so I'm very glad they added it. And Jamie goes into detail about, like, how it impacts binary sizes and things like that. Right? Mhmm. Cool stuff. What blowback did he get?

So 1 of the limitations actually you touched on is that it this doesn't keep dev dependencies separate from compiled dependencies. So they're all kept in the same list, which means if you have well, let's use an example of a of a project I'm working on, 1 of my open source projects. It targets Go 1.17, but a couple of the tools I use depend on newer version of Go, which means I can't keep them in the same go dot mod file. So it won't solve that particular problem for me. I understand.

So it's

It's still an improvement over the status quo over the situation for today. It's still an improvement, but it's maybe not, the ideal scenario is, it's maybe not the ideal improvement everybody would want.

I think it it doesn't mean, like, that's the final, version of this. Right? Features in Go, evolve and develop.

And something to keep in mind, you can actually specify, if you want to, a separate dot mod file. So you could create a tools dot mod file that you use, to track your tools separately. So there is a workaround. It's just maybe not as ergonomic as maybe people want.

Yeah. I don't like having too many project management files in my root directory and already having 2 in every programming language I work in, which is like the dependencies list and the dependencies lock file, And the readme and like, 100 files to configure linters. Like I'm very happy with go projects where you have Golang cielid config, go mod and go lock, right? And that's it. Versus like other languages I could think about, mhmm, mhmm, node, where you have, like, 15 files at the root of the project just to get your tools, like, configured and going.

Shai, I am so excited. We have, as of right now, as of for this recording, 99778 downloads of our podcast, which means that tomorrow with release of this episode you're listening to right now, we will hit 100000 downloads.

Damn. That's cool. I'm wondering how many dishes that translates

to. Because I

think our podcast is the perfect podcast to do dishes with. Right? Because it's like you wanna be concentrated. I don't want people to be driving and trying to imagine, like, okay, wait wait groups and whatever just to be imagining them veering into the second lane. But it's I think it's exactly, like because doing the dishes should take you about, like, fifteen minutes.

Pure news. How

long does it take you to wait to wash, like, a single plate when you do the dishes?

I don't wash the dishes. I put them in the dishwasher.

I'm gonna Olga, my wife, if you're listening, stop listening right now. This is a contentious this is probably the most contentious point in our marriage.

Oh, no.

You you're holding a plate in your hand. Yeah. It's dirty. It has, like, stuff on it, like ketchup.

Okay.

Do you clean it before you put it in the dishwasher so the dishwasher Ketchup, no.

If if it has solid food on it, yes.

I clean it before I put it in the dishwasher with soap.

Then then then just put it in the cupboard. You don't need the dishwasher anymore.

I will die on this hill. It keeps the dishwasher working for longer, and the dishes come out clean.

Yeah. They they come out clean because they go in clean.

Before you had before you had a dishwasher, how long does it take to wash your plate? Like, ten seconds? Nah.

Just a few seconds.

Fifteen seconds.

Yeah. Maximum.

We're talking about 22000000 22 and a half million plates washed.

That's a lot of plates.

Yeah. People need to eat. Thanks for downloading our podcast. It's so cool of you, everybody.

Alright. What else can we talk about on this, not ad break?

How can people reach us?

Yeah. You can just talk

to us.

Yeah. Cupofgo.dev is the website where all the other links are. You can email us [email protected]. You can find our Patreon there. Support us on Patreon. It helps to pay to produce a show. You can find us on Slack. We're the cupago Slack on the Gopher's Slack cupago channel on the Gopher's Slack. We've got LinkedIn. We've got

If you wanna get technical, it's the cupago channel on the Gopher workspace. Oh. Yeah. I got really into Slack, non maculature when I worked at the Reco because it was, like, AI protection on SaaS applications. And I found that nobody cares about whatever product managers decide to call things. Oh, these are channels. These are threads. These are workspaces. Nobody cares about these words. They're just gonna call it the the Mhmm.

Makes sense. Anyway, yeah. Get a hold of us. We'd love to hear from you.

Yeah. You can email us at capago dot dev, that is @newsatcapago.dev, I mean. And we love to get your emails as well. So far, they've been nice. Last thing we wanna update you about before we jump to the interview is our one hundredth episode.

I think we did. I think we should get on to the interview.

To the interview

Sean, are you excited about Go 1.24?

I'm excited about it, definitely. I saw all of the

Excited about reading reading all of the release notes, and And that's probably all you're gonna do. Right? Just read the release notes?

Nah, man. I'm I'm skipping all that. I I read the source code and just try to understand what happened.

Okay. That's cool. Yeah. No no no need to interact with it at all.

No. I just I read, and I think I understand it. Why? Do you have any other suggestion?

Well, I mean, I I don't know. I've I've been doing the same thing for for most, you know, most of my programming career. I just read books about programming and call myself a programmer. I don't really do anything with it. But I've been wondering

That's why you find grammar problems in me.

Maybe I should try interacting with these languages. I wonder if there's any way we could, you know, get some interactive, I don't know, documentation, maybe even release notes. That would be cool.

That sounds impossible. Anton, what do you think?

Anton, welcome to the show.

Hi, guys. Thank you for inviting me. Yes.

And thank you for your interactive release notes and all the other contributions you've made. Before we talk about those things, though, why don't you tell our listeners a little bit little bit about who you are and what you do?

Okay. My my name is Anton. I do some open source stuff, and, I write, interactive maybe I can call them guides or books and interactive articles on my blog. That's mostly what I do in my free time. So that's it.

These are calling them just, interactive, blog posts or guides makes them sound way less important than they are. I think they, just gave a lot of people, excitement about the new, versions of Go because now they can finally understand what it means, from, like, a thousand comments on a discussion, on, like, a proposal with super smart people that definitely understand what they're writing, but I don't. Hey, click run here, and it's gonna work. And actually, I wanna I wanted to ask you about this first, the interactive like, the little interactive windows you have on your site, that's your thing. Right?

Yes. That's right. That's, actually 1 of my open source projects. So the idea behind it is very simple. I think that 1 of the most important, things in in technical writing, like, blog posts or documentation, is examples.

Well, it's called Codapi. It's c0dapi.org. And definitely, if you do any kind of technical writing, blog posting, I think specifically if you're, like, a development tooling company. Right? If you have a library, your AI agent, blah blah blah, all these sorts of things.

Yeah. Sure. That's what I do.

How long have you been doing the interactive release notes now that I think about it?

I think the first one was, something for Go 1 20. It was not the full release notes. It was kinda, you know, like, cherry picks from Go one twenty. And, I think the full 1 was for 01/22, '20 03/00, and now '24. So that's, last 3 releases. And do you

know I don't know. Maybe you have analytics or or something. How many people read these? I've seen them on every single I've seen them on every single feed of Go stuff that I I'm a part of. Obviously, our own, but that's biased.

I'm afraid not very many people read them. I'm afraid people don't read much at all. Usually, what they do is they like it on social media. Sometimes they repost it, but, I think very few people, read such long blog post. But I suspect that even less people read the official release notes

That's probably true.

To the end. I mean To the end. Maybe they open them and read the beginning, but, well, I'm not sure many people read them to the end.

If that's what we're saying, I'm guilty. I mean, with both your interactive ones and the official ones, I tend to skim the highlights. But, like, on yours, I've I've really enjoyed yours the last, couple times. Because although I don't read them top to bottom, I pick the ones I'm interested or or in particular, the 1 I'm most confused about. And then your little examples are a great place to to to to clear up that confusion because I can whatever the thing is, I can play with it, and then I can change the code around it.

Thank you, Jonathan.

Does it work? Like, the the history of this show is basically, we started it Jonathan did some podcast before. Like, this is my third pod podcast. But the the main driving force behind doing the show is learning about Go and making sure we're, like, knowledgeable about what's going on so we're better, backend programmers or Go programmers. I feel like in order to write these, release notes, you probably understand the release a lot better once you finish the blog post. Right?

Sure. That's how it works. Yeah. Best way to learn is to write about something.

Yeah. Cool.

Any any specific things about 01/24 that were hard for you to, like, figure out and write about? Like, I know, synthetic times or directory scope or the cleanup stuff, anything that, like, writing the example really gave you in, like, moment? They were like, oh, now I understand. Now I understand what this proposal actually means.

Well, I think, the most confusing 1 was the 1 with test context. Because I I for a long time, I just I didn't get why would we need a helper here. So you can just, you know, create a context and cancel it. And, by reading the proposal and the comments below it, I understood that, basically, that's a kind of synthetic, syntactic sugar, so to say. It's basically just the context which is attached to the test, which create which, exists inside the test until the test, completes.

I think the best proposals we we I definitely read a lot of, proposals a lot more than I should because of this show. Right? Because I tried to find interesting ones. The ones that don't include, like, an example, just like the first after the first few lines, they have a line of code that says, here's the problem, and here's after the my proposal, here's the solution. The ones that don't include that, usually, I need to write read like 3 or 4 times.

Yeah. That's, currently the book I'm working on. It's, gist of Go concurrency. And the the motivation, for the book is, it's similar to the other kind the other stuff I I write. When I first learned to go concurrency, I I read a book.

And you're sort of halfway through it. Right? You're it's not finished

yet? Well, yes. I have all the all the material, but, I only published currently. Half of it, the first half is about the high level concurrency primitives like select and coroutines and context. And the second half is more low level stuff like synchronization, mutexes, and condition variables, and stuff like

that. Very, very cool. Just to give our, listeners a call to action, if you like the interactive release notes and you wanna learn more about concurrency, they can preorder it right now. Right?

Yeah. Sure. Just, they can visit, my website, which is Antonz.org. And, it's all there. All the books are available to read on the website. And if, if they want to to, you know, support my work, sure, they can preorder, the book, or they can just, read it for free on the website. It's also a possibility.

Is is your technical writing your your main source of income, or are you working as well? I'm sorry if that was already discussed.

My my work, with, writing and the the open source projects definitely is is not a source of income. Well, it, it earns me some money, but not much. Yeah, I I work for a commercial company. I program

just Very good.

Just as a professional programmer. Well, I mostly program in Python. And

Oh, really?

Yeah. That's it. Maybe 10% of my time, I program in Go.

I don't wanna sound too too negative, but I hope you have more Go in your professional life as well.

Well, you know, it's it's an interesting combination, like Python and Go. I think they I think they complement each other pretty well because of how different they are. Yeah. It's so having, both Python and Go in your tool belt, you can, solve nearly any problem with the language which is best suited to the problem. Well, excluding, of course, the front end stuff, which is Yeah. Another topic.

The what I've found, like, I think it was yesterday, the person I think is called Charlie Marsh, said that they're gonna release a Rust based type, thing instead of mypy. And they already released the UV for instead of, like, poetry or pip. And they already released rough instead of black and eyesort and all these tools. So the moment the entire Python tooling tool stack is gonna be replaced with, like, native code, then I'll be happy to use it. But I've I've just spent so much time debugging people's virtual environments and debugging, like, stupid problems that Go doesn't have.

Well, it's an interesting thing. Just listening to I think it was your previous episode, I heard about 2 of the proposals made by, Jan. One for about error handling, and another 1 is about sync v 2. So I think both are interesting examples of the, current, Go development. So basically, what I've discussed, with Jan and, what he, added to the, sync v 2 proposal after, some discussion, additional discussion, is, as I read it, basically, every package which uses any is a potential candidate for v2 in the standard library.

So so more v 2, to bring, like, generics and and, like, things we agreed we can improve, improve across everything. If we agreed we're doing generics and it's already in, do it for everything. But if we agreed error handling looks like this, keep it the way it is. Cool. Yep. Jonathan, what what are you excited about in modern Go?

I'm actually excited about the new, context and testing. I'm gonna use that a lot. It'll it'll I mean, it's not a big deal, but it'll make my tests just ever so slightly, less boilerplate y, I guess.

Nice. My my thing the thought process for such a question is so different. I was like, oh, what am I excited about in Modern Go? Well, it's because it's all formatted the same, it has a slight edge in LLM code generation. So I really hope it becomes more popular because the code is better the generated code is better because it uses tabs for white space versus spaces like Python.

What was the biggest surprise or challenge of learning Go?

Yeah. Like, when you learned what was very difficult for you? This year, we we have a new question. Who was the person who influenced you the most in the Go community? Like, when you think about gophers, who do you think about? It could be, like, someone we know. It could be someone from work. It could be someone from university. Like, it doesn't have to be a famous person, but we would be interested to hear who influenced you, Anton, in your, like, Go development journey the most.

Well, I think, I won't be very original here. When I learned Go, I, I read a lot the Go blog. I think it's a great source of, learning materials and also the, like, thinking behind the Go language, thinking of the people who created the language, who created, the core, packages. And I think, a lot of blog posts, were written by Rob Pike, at least in the previous years, not so much in the later years. So, probably Rob Pike is the person from whom I learned a lot about Go, about what is, you know, like canonical goal, like things that play at the heart of the language and philosophy, this kind of stuff.

Well, you're definitely original because, I think you might be the first or second interviewee who's answering this question this year. So everybody else is copying you. Don't worry about it. Well, Anton, thanks a lot for coming on the show. We talked about, like, the various, links, but and by the way, listeners, obviously, all the links are in the show notes.

It's, antonz.org, and, everything is there, all of my works and the links to the all kinds of social networks. Everything is there. So that's it.

Cool. Cool. Cool.

Thanks a lot for coming on. I can't wait to get the next interactive release notes. Maybe you think not a lot of people read them, but, Jonathan and I do, and we very much enjoy doing that.

Thanks for coming on, and keep up the good work.

Thank you.

Exit up. Goodbye.