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

Episode Transcript
Available transcripts are automatically generated. Complete accuracy is not guaranteed.
Shay Nehmad (00:00):
This show is supported by you. Stick around
till the ad break to hear moreabout that and other exciting
things. This is CuppaGo for Jan.31, 2025. Keep up to date with

(00:22):
the important happenings in theGo community in about fifteen
minutes per week.
I'm Shay Nehmad. I'm JonathanHall. And our first interview
for 2025 is up. Yay. We have apretty cool show, a lot of
proposals to chew through, andan interview with Anton of the
the famous interactive releasenotes.

(00:43):
Yes. I'm excited about it. Itwent pretty well. We were doing
the magic of editing thing wherewe already did the interview.

Jonathan Hall (00:52):
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 theinspection and all that stuff,
asked for a little bit of extramoney to help replace the roof.
The buyers agreed. So we'redoing well.

Replace the roof.

Yeah. It's got an old roof. Buyers are gonna help
pay the sellers are gonna helppay 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 theroof replaced first, of course.

Nice. That sounds prudent. I just placed a ton of
solar panels on my factorialplanet, 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 mebecause I love proposals. It's 1
of my favorite parts of theshow. I don't know. I I I like
the forward looking into thefuture telling what what full
things Go is gonna have lateron.

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 proposalsounds good.

It does. It sounds really, I don't know,
high-tech or something. So theJava developers among us are
probably already familiar with,Java's flight recorder,
capabilities. Go is gonna begetting 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 sometimessomething interesting happens in
your program. By interesting, Imean, like, something probably
unexpected. Could be a bug orjust unexpected behavior, and
you wanna maybe debug that. Soyou want to do some sort of

(02:45):
tracing to see, you know, whatwhat was happening. Pretty
expensive to have tracing on allthe time.
You know, it creates hugeamounts of data that you
probably almost certainly don'tneed most of the time. So maybe
if you could wait until thatinteresting thing happened and
didn't get a trace, except thatyou never know when that
interesting happened until afterit happened. So the idea with

(03:05):
flight recording is that it doesthis tracing for you in a
circular buffer. And then whensomething interesting happens,
you can say, okay. Give me thelast chunk of this buffer now.
Dump that out to a file, and Ican do my investigation. So
that's gonna be added in,probably, I'm guessing, go 1.25.
There's a fairly detailed APIhere in the trace package,
runtime trace. I haven't lookedat it in super detail. This

(03:28):
isn't the kind of feature Ithink most of us are gonna be
using a lot, but it's reallygood that it's there for for
those times when we need it.
So I'm I'm kinda looking forwardto this. I don't know when I'll
use it next, but I'm I'm gladthat it will be available when

I need it. What what sort of information does it
write? Like, okay. So it's acircle 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 gonnagive you basically the same sort
of information you can alreadyget with Go's, tracing support.
So, how long it spends inparticular Go routines or on
certain functions, how manymemory allocations, things like
that.
The the the main thing is thatyou don't have to run it in like
a you don't have to capture allthe data from your tracing to

(04:10):
get what's valuable, because ofthe 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 cando flight recording, what's the
point of, like, buying Sentry oror Surajit tools?

I think it's good. And I'll refer back to I
think it was the interview I didwith John Bodnar. I think he
missed that interview, theauthor of, 1 of the Go books
that, that I like. And he wasreally excited about some of
this. I don't know if it wasthis specific proposal, but he
was really excited about some ofthe real time tracing that Go
was hoping to add because itcould it make it easier to

(04:57):
export some of that data toservices like Sentry or Datadog
and and things like that.
So I I think it's probably goodfor them. The alternative is, in
many cases, they either writethe code themselves or they just
can't get access to that data atall. So, I mean, I guess there's
an argument argument to be madethat, now that I can get the
flight recorder by myself, whywould I bother with Sentry? But

(05:17):
I think, really, Sentry couldstill make this data much more
easy to consume and and digest.

Yeah. That that makes sense. Like, integrated
with the rest of their featuresand whatever. Yeah. Generally,
flight recording seems like asuper useful technique.
I'm really surprised in in somesense, I'm really surprised it's
not implemented already. I feellike the sorts of, events that
trigger flight recording, arethey just panics? Or can you

(05:46):
configure, like, hey, write to afile whenever you want? Like,
I'm trying to understand if it'sa runtime thing, or if it's a
user thing. Like, how how highup is it?
Looks like it's gonna you onlyhave 1 flight recorder and only
1 start is allowed, at leastaccording to the suggested API.
And you can even check if it'senabled or not enabled. But I'm

(06:08):
just wondering what sort ofevents might trigger it.

So I think you could decide when to trigger it.
I think you just get to call theright to when when you want the
data. So it's up to you toinstrument 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 toother than doing the rest of
your cleanups.
Cool. Cool. Cool. Yep. Seemsvery useful, and it's been,
like, waiting for a long time,and now it's been moved to

(06:46):
approved.

Yay.

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

Yeah. Speaking of, waiting for cool things to
happen, why don't you tell usabout 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 Ithink what's happening here, and
we might, like, only see it now,because there's been, like, a
change of the guard in in theproposal ownership.
Right? It was Russ, and now it'sAustin. They might be doing,

(07:40):
like, a backlog cleanup, sort ofthing, going through great
proposals from the past. This 1is I'm I'm not sure I 100%
understand it, and it soundsfrom 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 racecondition.

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

So the the this is about sync wait group, and
the the proposal isn't to changesync wait group. It's to add a
vet check for 1 particularmisuse of sync wait group. So if
you've used sync wait group, Ithink it'll make sense to
explain this over over audio.You you create a sync wait
group, and then you callassuming your wait group is
called w g, you call w g add,typically, w g add 1 for every

(08:41):
goroutine you're gonna start andthen wait for. The common misuse
is to call that w g add withinthe goroutine.
You should call it before youstart the goroutine. If you call
it within the goroutine, there'sa chance, that the wait group
will the the wait function onthe wait group will return
before the goroutine hasactually kicked off and started
doing things. So that's thethat's the potential race

(09:03):
condition.

The the main thing that surprised me here in the
proposal is that it's notdetectable by the race detector.
Like, why wouldn't it bedetected by the race detector?
Isn't isn't that the whole pointof the race detector?

The race detector specifically detects, data
races, and this is not actuallya data race. This is a case of a
process finishing before a goroutine has has started. So it's
a different it's a differentkind of race.

The interesting thing, like, this is a pretty
old proposal. There's a lot ofdiscussion here. 1 thing I like
is, how, it's planning to getresolved. Right? It's not a side
of, proposals we discuss a lot,like the implementation.
But at least the the way thislooks here is just gonna look

(09:54):
like the linter rule is ispretty simple. It's literally
going to look for the dot addfunction call in the first line
of a clause. That's it, of aclosure closure, I mean. It's
simple to implement it from thedata they looked at. It has 0%
false positive rate.

(10:15):
Right? Even though it's not aselegant as, like, trying to
analyze whether you did itcorrectly or right. It's it's a
very I don't wanna sayboneheaded, but it's like a very
straightforward approach tosolving the problem, which I
think it's a good, like, eightytwenty trade off. Right?

Yeah. Indeed.

Or or do you think, like, implementing this without,
like, parsing the AST andactually trying to figure out
what's the path, etcetera,etcetera, all the crazy
heuristics? Do you like, do youthink 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 maybeif you have Go routines calling
Go routines or you're you'redoing something weird, you might
not catch it. But I don't thinkthat would be a false negative.
I don't think you're gonna getfalse positives very I I can't
imagine how you would with witha simple check like this. So I I

(11:10):
think it's a good a good thingto add.

The the most fun part is, Alan Donovan, posting
the static check analyzer andfinding, 57 matches, all of
which are true positives forthis case from, like, real
projects, like Caddy, Go2Byte,and OmniScale, and, like, just

(11:33):
real life projects that havethis, mistake. So I think that's
the strongest argument out ofany, like, squabbling you can do
in the comments. Hey, I found 57people who did this wrong
exactly in the same way. Weshould 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 acompiler error. Almost.

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

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

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

Cool. So that has been accepted. And with the
simple implementation, we weshould 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 notactually a proposal yet. It's
not tech I guess it's a it'sstill in discussion phase, but
we we've talked about it before.
So I think it's worth bringingup, and it has reached a new
milestone. And that is the newJSON v 2 package. We had Joe
Tsai on the show a long timeago, last year, I think, to talk

(13:02):
about, JSON v 2 when the thenew, discussion topic was
created about that. The excitingbenchmark is that the official
proposal is in draft stage andshould become an official
proposal very, very soon. So Iwill have a link in the show
notes to the draft proposal toGitHub issue on the JSON v 2

(13:23):
experiment repo, not on theGolang Go repo, but we should be
having that pop over to theGolang Go repo pretty soon as an
official proposal.
And then I imagine we'll have aa JSON v 2 pretty soon in 01/25
or maybe 01/26.

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, fortyminutes ago commented on. And
just looking at his comments, II picked something interesting
from this. By the way, like, a50 lines of of proposal,

(13:59):
detailed APIs, etcetera,etcetera.
This is like a proper RFCdocument, that you can print in
order to sleep on. So, 1interesting thing about the
proposed implementation is to doit in x slash JSON

Mhmm.

Module and not just in JSON v 2 in the standard
library. Users who are usingolder versions of Go can still
use the v 2. Yeah. And I likethat. It will use type aliases
to the Go standard library, soyou should be you should be good
other way.
Like, you don't even I think itwould really help with adoption
and testing because you don'thave to wait until Go releases

(14:40):
and RC and, like, get everythingin 1 package. You can just pick
like, if you really want theJSON v 2 experiment, you can
just take it.

Right? Yep. And to be clear, this will be a
clone. The go golang.org/x/jsonwill 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 wrongwith JSON? Just in general.

So I think the most compelling argument for
JSON v 2 is it will be muchfaster. Fewer memory
allocations. The the in in myopinion, the biggest weakness of
the current, JSON implementationis although it appears to work
on byte streams, you know,there's an encoder and decoder
that takes an IO reader or usesIO writer, It actually reads in

(15:26):
the entire buffer before itstarts, iterating through it. So
you can't just send it to 2terabytes of JSON and expect it
to do the right thing. It'sgonna read that into memory
before it starts doing stuff.
The new 1 will actually behaving capability of operating
on JSON screens properly as youwould expect. It has many, many

(15:46):
other improvements, but this isthe 1 that I think will, will
sort of magically improveeverybody's life. It'll just
make JSON encoding and decodingfaster and use less memory.
Cool. Cool.

Cool. This sounds like a good, like, big project
to join, like, if you wanted toright? Like, a deep project. If
you if you're taking a yearsabbatical in between startups
or something, you plan todevelop a terminal emulator, but
Ghosty has already done that,doing the JSON v 2 for Go sounds

(16:18):
like a great project to joininto. 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 beconfusing. 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 ofGo, channels out. And if that
name, rings a bell, a, it'sbecause he's on the, probably,
the name of this episode. And,2, because he's the interactive
release notes guy. And his bookis also filled with interactive

(17:21):
examples.
I think it might be the best wayto learn. If you're into reading
and not doing, I think it's thebest way to read, about Go
concurrency that exists today,including official
documentation, includingeverything. I highly highly
recommend it. It is. You caneven stick around, for a few

(17:43):
minutes, and we'll get to anactual interview with him.
But it was on the lightingground backlog, like, forever,
and I was like, oh, we find wealso talked to him today. So let
me take it out of the backlog.

Well, I wanna call out, an article from 1 of
our listeners, and he's been onthe show before too, Jamie
Tanna, who wrote, a little shortblog post called Go 1.20 Go tool
is 1 of the best additions tothe ecosystem in years. It made
it around on all the cool placeson Hacker News and Reddit, I
suppose. It got a little bit ofblowback. We'll put links to

(18:17):
some of that too. But it's stillI think it's a nice overview of
this new tool called tool, thethe tool tool.
We talked about it long ago, butit's basically a way to track
dependencies, go baseddependencies that aren't
compiled into your code. So ifyou're using, say, open API
generation or or gRPC orsomething like that that does

(18:38):
code generation for you or someother tool, this will help track
those versions and and makethat, easier for you.

I I think it makes a lot of sense, or I should say
it another way. Any otherlanguage I use has, dev
dependencies. Right? And Ideveloped in Python, so Poetry
or UV have the dev dependenciessection. And when you program in
Node, you have minus minus savedev whenever you install a
thing.
So usually, there's a very cleardelineation between what do you

(19:09):
install for production and whatdo you install for development
generation, tooling, and thingslike that somewhere in the
equivalent of the Go mod file.And in Go, you just don't have
that. Always very surprising.And then you have to do this,
like, weird ass Go tools file,right, where you do tools.go and
you don't have anything in thereand all the imports are naked.

(19:29):
It's like the root cause mightbe because it's coming out of
Google, and they probably have ascript that installs all the
tool you need.
Right? Because it's in acorporate setting.

Mhmm.

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

So 1 of the limitations actually you touched
on is that it this doesn't keepdev dependencies separate from
compiled dependencies. Sothey're all kept in the same
list, which means if you havewell, let's use an example of a
of a project I'm working on, 1of my open source projects. It
targets Go 1.17, but a couple ofthe tools I use depend on newer
version of Go, which means Ican't keep them in the same go

(20:20):
dot mod file. So it won't solvethat 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 idealscenario is, it's maybe not the
ideal improvement everybodywould 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, aseparate dot mod file. So you
could create a tools dot modfile that you use, to track your
tools separately. So there is aworkaround. It's just maybe not
as ergonomic as maybe peoplewant.

Yeah. I don't like having too many project
management files in my rootdirectory and already having 2
in every programming language Iwork in, which is like the
dependencies list and thedependencies lock file, And the
readme and like, 100 files toconfigure linters. Like I'm very
happy with go projects where youhave Golang cielid config, go

(21:22):
mod and go lock, right? Andthat's it. Versus like other
languages I could think about,mhmm, mhmm, node, where you
have, like, 15 files at the rootof the project just to get your
tools, like, configured andgoing.
My, final thing for the lightinground, this might not be as fast
and snappy as we like forlighting round, is, Dreams of
Code, which I talked about, lastweek, came out with another

(21:45):
banger, just a short videoupdating on his course that he's
he's building. He's building anew course, which is cool, and
he's doing it. He, like, lookedat various course platforms
where he could sell the thing.Right? Then he didn't like any
of them, and he wrote his own, a% in Go, Like a full stack web

(22:06):
app, in Go in a stack calledgoth.
I forgot about the whole thingwhere you have LAMP stack,
right, and, like, acronym basedtech stacks. Do you know what
I'm talking about? Soapparently, there's the goth
stack. Have you heard of it? No.
It's Go, Temple, and HTMLX.Okay. The important part, it

(22:29):
doesn't have a JavaScriptframework. Like, it's not React
or Vue or Angular. And he claimshe built his whole, like, course
platform in it, and he's veryhappy with it.
So I'm I'm, like, happy thatit's an option for people who
wanna do it. And, you know, itseems like there's a wave of
anti JavaScript frameworks withthis and Alpine JS and things

(22:50):
like that. But just if you like,Dreams of Code stuff, if you,
liked his interview with us orhis videos, don't miss out on
this 1. It's all it alsoexplains why he hasn't been,
like, on top of his releaseschedule recently, building his
own, content platform instead ofjust, shipping some courses,

(23:12):
which honestly, I respect. Like,building your own thing instead
of, picking something off theshelf when your thing is being
an engineer that, like, trackson multiple levels.
That does it for the lightninground. Let's move to a quick ad
break. And after that, we have,like I said, a million times
already, an interview with Antonthat I'm pretty jazzed about.

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 withrelease of this episode you're
listening to right now, we willhit 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'slike you wanna be concentrated.
I don't want people to bedriving and trying to imagine,
like, okay, wait wait groups andwhatever just to be imagining
them veering into the secondlane. But it's I think it's
exactly, like because doing thedishes should take you about,

(24:25):
like, fifteen minutes.
Right? And then while we cleanoff, the ad rate goes on. And
then if you care about theinterview, you can check that
out. And if we're talking abouta hundred thousand downloads,
right, we have a hundredthousand downloads times fifteen
minutes. So it's a million andfifth it's one and a half
million minutes of just purenews.

(24:48):
Right?

Pure news. How

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

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 acontentious this is probably the
most contentious point in ourmarriage.

Oh, no.

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

Okay.

Do you clean it before you put it in the
dishwasher so the dishwasherKetchup, 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 dishwasheranymore.

I will die on this hill. It keeps the dishwasher
working for longer, and thedishes 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 yourplate? 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 ofyou, 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 emailus news@cupofgo.dev. You can
find our Patreon there. Supportus on Patreon.
It helps to pay to produce ashow. You can find us on Slack.
We're the cupago Slack on theGopher's Slack cupago channel on
the Gopher's Slack. We've gotLinkedIn. 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 Iworked at the Reco because it
was, like, AI protection on SaaSapplications. And I found that
nobody cares about whateverproduct managers decide to call

(26:48):
things.
Oh, these are channels. Theseare threads. These are
workspaces. Nobody cares aboutthese 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. Andwe love to get your emails as
well. So far, they've been nice.Last thing we wanna update you
about before we jump to theinterview is our one hundredth
episode.
So in just two weeks' time,we're planning to have our one

(27:21):
hundredth episode, celebration.It's gonna be live, live in the
sense that you can join therecording. Feb. 13, right before
Valentine's Day, we plan to doit at, 8PM Israel time, which is
like 6PM UTC. So I think mostpeople in Europe could easily
join.

(27:41):
And if your morning gets sort offree, in The US, if you can get
a bit later into work or if youwanna join from work, right, and
grab a conference room and somecoffee, bring some bagels, that
could be cool if you're runningthe back end guild at work or
something. Yeah. We're gonna donews. We're gonna go through a
few proposals. We're gonna tryto keep it very, opinion light

(28:04):
and content heavy.
And then instead of doing aninterview, we're just gonna do a
live chat, open microphone, andand we we're gonna have some
questions and some fun stuff,maybe even some activities.
We'll see what we manage toscrunch up. We really would like
y'all to join us because we'vebeen talking about the live
episode forever. We reallywanted to do it for a long time.

(28:24):
And this show, I I wouldn't goas far and as influency to say
it wouldn't happen withouty'all, but definitely wouldn't
have lasted that long without,like, the community and all the
interesting people that came onto interview and all the
responses and the and thesupport we got.
So we would really like to toshare this experience of, like,
recording an episode with,everybody. And if it's fun,

(28:46):
maybe we'll do it, like, wedon't have to wait a hundred
episodes to do it again. Butlet's try to do it once and try
to do it right. Did we covereverything?

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'sprobably all you're gonna do.
Right? Just read the releasenotes?

Nah, man. I'm I'm skipping all that. I I read the
source code and just try tounderstand 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 othersuggestion?

Well, I mean, I I don't know. I've I've been doing
the same thing for for most, youknow, most of my programming
career. I just read books aboutprogramming and call myself a
programmer. I don't really doanything 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'sany way we could, you know, get
some interactive, I don't know,documentation, maybe even
release notes. That would becool.

That sounds impossible. Anton, what do you
think?

Anton, welcome to the show.

Anton (29:54):
Hi, guys. Thank you for inviting me. Yes.

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

Anton (30:05):
Okay. My my name is Anton. I do some open source
stuff, and, I write, interactivemaybe I can call them guides or
books and interactive articleson my blog. That's mostly what I
do in my free time. So that'sit.

These are calling them just, interactive, blog
posts or guides makes them soundway less important than they
are. I think they, just gave alot of people, excitement about
the new, versions of Go becausenow they can finally understand
what it means, from, like, athousand comments on a

(30:44):
discussion, on, like, a proposalwith super smart people that
definitely understand whatthey're writing, but I don't.
Hey, click run here, and it'sgonna work. And actually, I
wanna I wanted to ask you aboutthis first, the interactive
like, the little interactivewindows you have on your site,
that's your thing. Right?
It's not a different library.

Anton (31:05):
Yes. That's right. That's, actually 1 of my open
source projects. So the ideabehind it is very simple. I
think that 1 of the mostimportant, things in in
technical writing, like, blogposts or documentation, is

(31:26):
examples.
Because, I think that, we,people, generally learn best
from examples and stories,because, that's how our brain
works. It's just wired to, youknow, to stick to examples and
stories. And what can be betterthan just examples, only

(31:49):
interactive examples? So that'swhat I think. So I've made this
tool, which is a code sandbox,and also a tool for creating
interactive examples in any kindof technical writing, like
courses, and blogs, and thingslike that.
And I use it personally all thetime for my blog, and I try to

(32:13):
encourage other people to use itwithout much success,
unfortunately. But, well, I try.

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

(32:43):
And SDK generation companies,right, all these things, they
always have code examples ontheir side. And I always don't
believe the examples becausethey just look a little bit too
perfect. And I'm like, itactually lowers my trust when I
see code that I can't just copyinto my editor because, you
know, the imports are missing orit it has a tiny syntax error.
My outlook on it woulddefinitely change if I had

(33:06):
these, executable snippets onyour site. So anybody here who
listens and works in devtooling, go check out the
c0dapi.org.
And these little snippets of,like, executable code are thing
that you they are the way youbuild the interactive release
notes, right, for every version.

Anton (33:26):
Yeah. Sure. That's what I do.

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

Anton (33:31):
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.

(33:55):
And do you

know I don't know. Maybe you have analytics or or
something. How many people readthese? I've seen them on every
single I've seen them on everysingle feed of Go stuff that I
I'm a part of. Obviously, ourown, but that's biased.
But Golang Weekly and Golang'sSlack channel in the Slack
workspace where Jonathan and Imet, the rants, rants and

(34:17):
repose, Slack and in Twitter andon, the links in, like,
Telegram. I I've seen it everysingle play on Reddit, the
Golang Reddit. Every singleplace that's a Go community,
I've seen these, interactiverelease notes. Do you know how
many people actually read them?

Anton (34:35):
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 suchlong blog post. But I suspect
that even less people read theofficial release notes

That's probably true.

Anton (34:59):
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 interactiveones 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, Ipick the ones I'm interested or
or in particular, the 1 I'm mostconfused about. And then your
little examples are a greatplace to to to to clear up that

(35:28):
confusion because I can whateverthe thing is, I can play with
it, and then I can change thecode around it.
I can, you know, hit run a fewtimes. So, I mean, I yeah. I
don't read straight through. Icertainly wouldn't read straight
through the release notes if itweren't for the show. I probably
read them more thoroughly than Iwould otherwise for the show.
But, yeah, I I read through topick the things that are most
interesting to me. I skim overanything about macOS or Windows.

(35:49):
I skim over anything aboutlibraries I don't use, etcetera,
etcetera. But, yeah, whenthere's something confusing,
your interactive release noteshave actually helped me. For the
last 2 releases, I think I wasaware of it with one point one
point twenty three, and thencertainly 1.24.
So so thank you. Even if I don'tread it clear through, it's it's
still a valuable resource forme.

Anton (36:08):
Thank you, Jonathan.

Does it work? Like, the the history of this show is
basically, we started itJonathan did some podcast
before. Like, this is my thirdpod podcast. But the the main
driving force behind doing theshow is learning about Go and
making sure we're, like,knowledgeable about what's going
on so we're better, backendprogrammers or Go programmers. I

(36:31):
feel like in order to writethese, release notes, you
probably understand the releasea lot better once you finish the
blog post.
Right?

Anton (36:41):
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, figureout and write about? Like, I
know, synthetic times ordirectory scope or the cleanup
stuff, anything that, like,writing the example really gave
you in, like, moment? They werelike, oh, now I understand. Now
I understand what this proposalactually means.

Anton (37:10):
Well, I think, the most confusing 1 was the 1 with test
context. Because I I for a longtime, I just I didn't get why
would we need a helper here. Soyou can just, you know, create a
context and cancel it. And, byreading the proposal and the

(37:31):
comments below it, I understoodthat, basically, that's a kind
of synthetic, syntactic sugar,so to say. It's basically just
the context which is attached tothe test, which create which,
exists inside the test until thetest, completes.
And then just before the testcompletes, it cancels. And it's

(37:54):
just handy so that you don't,forget to create a cancelable
context yourself and, defercancel it. It's just a simple
thing, but, it took me some timeto understand the logic behind
it because I think it wasobvious to the person who

(38:14):
proposed it, Mhmm. But it wasclearly not obvious, to me as I
read it and I read the comments.Somewhere in between the long
very long discussion, I finallyfind an example, just a small
example, of code, that made meunderstand, the point of of the
test context.

I think the best proposals we we I definitely
read a lot of, proposals a lotmore than I should because of
this show. Right? Because Itried 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, andhere's after the my proposal,
here's the solution. The onesthat don't include that,

(38:58):
usually, I need to write readlike 3 or 4 times.
And then, like five minutesbefore the show, I go to our
ticket backlog and I switch theuser from myself to Jonathan and
like, oh, no. You're you'reexplaining this 1 this week, not
me. Just to get out of it. So,again, I I just can't stress
enough that how, cool the,interactive release notes are,

(39:19):
and I really hope that therewill be a lot of content in Go
one twenty five so you'll have avery cool, interactive release
notes then because I alreadyread, the one twenty four one.
Other than the interactiverelease notes, though, we
mentioned at the top of the showthat you were working, like, on
a ton of stuff.
I think the highlight is, the,gist or gist of go book. Right?

Anton (39:40):
Yeah. That's, currently the book I'm working on. It's,
gist of Go concurrency. And thethe motivation, for the book is,
it's similar to the other kindthe other stuff I I write. When
I first learned to goconcurrency, I I read a book.
It's, well, it's a good book.It's actually actually, it's a

(40:05):
great book, but, it was verydifficult for me again to, to
get through it. And, well, whenyou read about, concurrency
primitives, like channels, andselect, and goroutines, it all
seems easier, right? It's simplestuff. But when you try to

(40:26):
understand how to really applyit, even in toy programs, it can
be quite confusing.
And usually the books, well,they don't help very much with
that. So I thought about writinga book, very heavy on examples,
as usual, and, of course, tomake them interactive, so that

(40:47):
people can, run them and changesomething, and see how, things
change when you, you know, runmore Goroutines or, introduce
mutexes or remove mutexes andstuff like that. So that's, what
I'm working on currently.

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

Anton (41:10):
yet? Well, yes. I have all the all the material, but, I
only published currently. Halfof it, the first half is about
the high level concurrencyprimitives like select and
coroutines and context. And thesecond half is more low level
stuff like synchronization,mutexes, and condition

(41:35):
variables, and stuff like

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

Anton (41:49):
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, youknow, support my work, sure,
they can preorder, the book, orthey can just, read it for free

(42:10):
on the website. It's also apossibility.

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

Anton (42:20):
My my work, with, writing and the the open source projects
definitely is is not a source ofincome. Well, it, it earns me
some money, but not much. Yeah,I I work for a commercial
company. I program

just Very good.

Anton (42:38):
Just as a professional programmer. Well, I mostly
program in Python. And

Oh, really?

Anton (42:45):
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 yourprofessional life as well.

Anton (42:59):
Well, you know, it's it's an interesting combination, like
Python and Go. I think they Ithink they complement each other
pretty well because of howdifferent they are. Yeah. It's
so having, both Python and Go inyour tool belt, you can, solve
nearly any problem with thelanguage which is best suited to

(43:19):
the problem. Well, excluding, ofcourse, the front end stuff,
which is Yeah.
Another topic.

The what I've found, like, I think it was
yesterday, the person I think iscalled Charlie Marsh, said that
they're gonna release a Rustbased type, thing instead of
mypy. And they already releasedthe UV for instead of, like,
poetry or pip. And they alreadyreleased rough instead of black

(43:46):
and eyesort and all these tools.So the moment the entire Python
tooling tool stack is gonna bereplaced with, like, native
code, then I'll be happy to useit. But I've I've just spent so
much time debugging people'svirtual environments and
debugging, like, stupid problemsthat Go doesn't have.
My instinct is, like, Python,ugh. But, obviously, you're

(44:06):
correct. There's different toolsfor different jobs that makes a
lot of sense. So we we have theall the content. We have the
book.
We have the interactive releasenotes. You certainly, made a lot
of people excited about thethings that have been released.
For sure, I'm, like, lookingforward to the next releases
just to know that just because Iknow I'm more equipped to deal

(44:30):
with what they what they bring.There is this notion of, like,
modern Go. Go 1 and Go onetwenty four does don't they look
similar.
They're not that different, butthey they are relatively
different. How do you see that,like, difference in the future
going forward? What are youexcited about in, like, modern

(44:51):
Go?

Anton (44:52):
Well, it's an interesting thing. Just listening to I think
it was your previous episode, Iheard about 2 of the proposals
made by, Jan. One for abouterror handling, and another 1 is
about sync v 2. So I think bothare interesting examples of the,

(45:16):
current, Go development. Sobasically, what I've discussed,
with Jan and, what he, added tothe, sync v 2 proposal after,
some discussion, additionaldiscussion, is, as I read it,
basically, every package whichuses any is a potential

(45:40):
candidate for v2 in the standardlibrary.
That's, basically what he said,as far as I understand it. So I
think, in the years to come, wewill see a lot more v2 packages
with generics and iterators,which are 2 things the Go team

(46:02):
seem to be very enthusiasticabout. Personally, I'm not so,
so much enthusiastic about thesethings, but, I understand, of
course, their position, and howthey see the language should
evolve, and the standard libraryshould evolve. So I think the

(46:23):
modern goal is, you know, isgoing to introduce more and more
generics, more and moreiterators. I hope it won't
introduce anything about errorhandling because I think we
should leave it alone.
It's it is verbose, it isboilerplate heavy, but that's

(46:46):
that is just the Go way. Go isverbose, and that's okay. And
error handling is also verbose,but it's okay. I hope this won't
change. As for, other things, Ithink, more generics or
iterators.

So so more v 2, to bring, like, generics and and,
like, things we agreed we canimprove, improve across
everything. If we agreed we'redoing generics and it's already
in, do it for everything. But ifwe agreed error handling looks
like this, keep it the way itis. Cool. Yep.

(47:24):
Jonathan, what what are youexcited about in modern Go?

I'm actually excited about the new, context
and testing. I'm gonna use thata lot. It'll it'll I mean, it's
not a big deal, but it'll makemy 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 waslike, oh, what am I excited
about in Modern Go? Well, it'sbecause it's all formatted the
same, it has a slight edge inLLM code generation. So I really
hope it becomes more popularbecause the code is better the

(48:01):
generated code is better becauseit uses tabs for white space
versus spaces like Python.
So it uses less tokens, thesesorts of, things. But honestly,
the the honest answer is that,the thing I'm excited about in
the in modern Go is the peopleworking in it. Like, I'm really
excited to meet people doingcool stuff. Usually, when you

(48:22):
work in in at least from thelast two years, I felt that
people who are attracted to thistechnology tend to have another
quirk that's cool. The averageGo programmer also have
something cool that they do,whereas the average just back
end developer that uses whateverlanguages, their company had
sometimes have less, passion ordepth.

(48:44):
I'm really excited about morepeople getting into this
language and getting to knowthem. And I think that leads us
pretty well to our, stumperquestion. So we talked about
this at the beginning of theyear, but our the first year of
doing the show, we asked peoplewhat feature would you remove
and what feature would you add?By the end of the year, we had 2

(49:05):
lists full of all the features,both to remove and to add.
People want to remove all thefeatures and add all the
features.
So we switched that question.Second year, we had what was the
question second year? I'm I'mblanking.

What was the biggest surprise or challenge of
learning Go?

Yeah. Like, when you learned what was very
difficult for you? This year, wewe have a new question. Who was
the person who influenced youthe most in the Go community?
Like, when you think aboutgophers, who do you think about?
It could be, like, someone weknow. It could be someone from
work. It could be someone fromuniversity. Like, it doesn't
have to be a famous person, butwe would be interested to hear

(49:42):
who influenced you, Anton, inyour, like, Go development
journey the most.

Anton (49:47):
Well, I think, I won't be very original here. When I
learned Go, I, I read a lot theGo blog. I think it's a great
source of, learning materialsand also the, like, thinking
behind the Go language, thinkingof the people who created the
language, who created, the core,packages. And I think, a lot of

(50:13):
blog posts, were written by RobPike, at least in the previous
years, not so much in the lateryears. So, probably Rob Pike is
the person from whom I learned alot about Go, about what is, you
know, like canonical goal, likethings that play at the heart of

(50:37):
the language and philosophy,this kind of stuff.

Well, you're definitely original because, I
think you might be the first orsecond interviewee who's
answering this question thisyear. So everybody else is
copying you. Don't worry aboutit. Well, Anton, thanks a lot
for coming on the show. Wetalked about, like, the various,
links, but and by the way,listeners, obviously, all the

(51:04):
links are in the show notes.
Wherever you listen to thispodcast, you can find them
there. But just 1 last time, ifpeople wanna find you or your
books or your open source stuff,where can they find you, and
where can they talk to you?

Anton (51:16):
It's, antonz.org, and, everything is there, all of my
works and the links to the allkinds of social networks.
Everything is there. So that'sit.

Cool. Cool. Cool.

Thanks a lot for coming on. I can't wait to get
the next interactive releasenotes. 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.

Anton (51:47):
Thank you.

Exit up. Goodbye.

All Episodes

Episode Transcript

Popular Podcasts

Stuff You Should Know

Dateline NBC

On Purpose with Jay Shetty

.css-15opob5{left:0;position:absolute;top:0.8rem;} All Episodes

.css-14f5ked{margin:0;word-break:break-word;display:-webkit-box;-webkit-box-orient:vertical;box-orient:vertical;-webkit-line-clamp:2;overflow:hidden;}What's coming beyond Go 1.24? A look at proposals, and interview with Anton Zhiyanov

Episode Transcript

Popular Podcasts

.css-r6mb8g{margin:0;word-break:break-word;display:-webkit-box;-webkit-box-orient:vertical;box-orient:vertical;-webkit-line-clamp:1;overflow:hidden;}Stuff You Should Know

Dateline NBC

On Purpose with Jay Shetty

All Episodes

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

Stuff You Should Know