Everything You Always Wanted to Know About Go 1.27 But Were Afraid to Ask
So we're gonna talk about 01/27 today, the only thing I can think about is the twenty seven club.
Jonathan Hall:What is the twenty seven club?
Shay Nehmad:Twenty seven club that, like, all the musicians die when they're 27. So if you live
Jonathan Hall:to be 27 Oh, yeah. Yeah. Okay.
Shay Nehmad:You know you're not gonna be a great musician. Right. Anyway, let's start this. I don't know if we should mention on the show. It's a bit macabre.
Shay Nehmad:This is Cup of Go for 08/28/2026. Keep up to date with the important happenings in the Go community in about twenty minutes per week. I'm Shay Nehmad.
Jonathan Hall:And I'm Jonathan Hall.
Shay Nehmad:And welcome to our Go one twenty seven recap episode. If you're new here, because usually people who listen to the new version release episodes are not regular listeners, welcome. Like I said, I'm Shay Nehmad. I've been co hosting this show for, like, three years now.
Jonathan Hall:It's been a long time, hasn't it? Yes. We've been doing this together. It's pretty cool.
Shay Nehmad:And normally, our episodes are not like this. They're like, we pick up two or three cool things and discuss them and it's shorter. But this episode, we're gonna give you what's it called? We're gonna give you the skinny on
Jonathan Hall:27 things I love about
Shay Nehmad:Go. Yeah. This episode, we're gonna try to review all the important parts of the Go one twenty seven release now that the release is officially out. It's not like release candidate debugging anymore or whatever. It's out out, right?
Jonathan Hall:Yep, it is.
Shay Nehmad:And let's start by before we go into the actual changes in, you know, the Go programming language, how do I upgrade? Let's say I have some Go code running right now. What do I need to do to upgrade and have Go one twenty seven running on my machine?
Jonathan Hall:There's two answers to that. One is just edit your go dot mod file to to save go 1.27, and it will automatically download go one twenty seven when you're compiling and running that module. But you probably also want to upgrade your the main version you're running on your system. Go.dev/dl. There you can download it for your operating system and follow the instructions there.
Jonathan Hall:It's pretty simple. Less than a minute, you'll have the new version installed.
Shay Nehmad:Yeah. And nobody will know because it's on the d l. Right? On the download. And never mind.
Shay Nehmad:That's right. But controversial question, shouldn't you do it with Brew?
Jonathan Hall:I don't even know what Brew is, so I don't know the answer to that.
Shay Nehmad:So Brew is like a package manager for Mac.
Jonathan Hall:Well, yeah, would be why I That's don't know it
Shay Nehmad:how I installed Go. Yeah. But I don't know if it's like the official way. I just install everything with it, so.
Jonathan Hall:Okay. Yeah.
Shay Nehmad:Alright. So we're gonna jump into the actual changes. Jonathan, you wanted to start with the headliner change, right? Yes. So yesterday I was in Muse, Muse concert.
Shay Nehmad:They were the headliners. It was really good. Uh-huh. But the supporting acts were also really good. It was Portugal, the man.
Shay Nehmad:Alright. Now I'm inspired. I've been inspired by Muse, talk about headliners and supporting acts. But you take the headliner, the big thing, generic methods.
Jonathan Hall:Should we save the headliner till the end, the way they do at a concert or should we start with the headliner?
Shay Nehmad:No, no. We're we're putting everything out.
Jonathan Hall:All right.
Shay Nehmad:It's like a restaurant. Whatever's ready, you bring it out.
Jonathan Hall:So the big the big thing that everyone's talking about is generic methods have landed. We've had generics for four and a half years now, and it's been annoying for many people that you cannot have a generic method. Well, now you can sometimes. The exception is that interfaces may not declare type parameters or that is generic methods. So you have to have you can only define a generic method on
Shay Nehmad:On a concrete type.
Jonathan Hall:Yes. On a concrete Yeah. Right.
Shay Nehmad:Right. Not an interface. Correct. So when would I use this? A method is basically just a function that's on a receiver, right?
Shay Nehmad:Right. Functions could could be generic so far, but you couldn't do it if they were a method. And now you can if it's a concrete type, if not if it's like an interface definition. So a simple example would be the
Jonathan Hall:one that was actually added in Go 127 standard library, and that is the N method on the RAND object in the rand library and in math rand v two. So you can have a cryptographic number generator called rand in this package. Mhmm. And you could call like the int method on it to get an integer or the float method to get a float, whatever. Well, now there's a new generic method called n.
Jonathan Hall:So the type parameter is the type you want and it can be an integer type. So an int, an int eight, an int 16, and so on and so forth. So that's probably the simplest example of where this can be used because it's already there.
Shay Nehmad:So instead of having to write all the methods out ahead of time and then calling them by name, depending on what type I have, now I can just call n and I don't have to define the type parameter because the compiler can like generics figure it out for me. It'll be like, oh, you're trying to put this into a int eight, so I'm only gonna randomize an int eight for
Jonathan Hall:you or And this also is a good way to talk about the limitation, and that would be that I cannot define an interface that declares that in the generic in method.
Shay Nehmad:This has been discussed at length as like a limitation of the of the language, but generally it's like, well, it's gonna be a dynamic property, so I can't know at compile time what to do, like how to solve it. Right? If I define an interface that has a generic as a generic type for one of its methods. Now I have a question. Do other languages have that?
Shay Nehmad:Can you have, like, an interface with a generic sentence method in, I don't know, C sharp or Java or whatever? I think you you can, but I don't know.
Jonathan Hall:So I I don't know the I don't know which specific languages, but as a concept, it should be possible. The reason they chose not to do that in Go, and this is, by the way, is the reason it took so long to add generic methods at all, is that they knew that there was a limitation, that it's it's impossible to calculate that in a fixed time. So it makes compilation slow if you want to do that safely. So the decision up to now has been just don't do that because there's not a we can't, you know to mathematically prove that this is correct in all cases can take an exponential amount of time. So either you don't have complete type safety, which kind of defeats the purpose of the strict strictly type language, or you make your compilation times grow with the complexity of your interface definitions.
Jonathan Hall:So the
Shay Nehmad:I know that, you know, in dynamic languages, obviously you can do this stuff. Can like define a protocol in Python and then the protocol has a method, is like an interface ish thing. That protocol has a generic type. But to me, this is a limitation and it's frustrating. There are viable cases where you want to define an interface and you say like, this thing handle generically all comparable types, right?
Shay Nehmad:All things that are comparable, I want to implement something, or I want you to implement five things, but their interface is that one of the methods takes a T. How do I work around that limitation today? Do I just put any and then do the generics on every single implementation and just write a doc, like a doc comment on my interface saying, oh, don't forget, when you take this, don't keep it as any. Just make it a generic thing.
Jonathan Hall:You you could do that. Actually work. You could do that.
Shay Nehmad:How should I work around this limitation?
Jonathan Hall:Yeah. So you mean by today, mean before 01/27. Right? Or with 01/20 01/27. Yeah.
Jonathan Hall:Okay. But but you want interfaces. So the yeah. Okay. So the solution before 01/27 could apply to the interfaces question in 01/27, and that is the solution is to not make it a method, but make it a regular function that accepts the receiver as its as an argument.
Shay Nehmad:Oh, so just like instead of being I dot some open parens, you'll be like open parens that accepts the I.
Jonathan Hall:Correct. Right. So you can still get around it that way. It's not as ergonomic and yeah, it has has drawbacks, but it can work.
Shay Nehmad:Yeah. By the way, I I this is a take it with a grain of salt because it's AI, so probably 80% correct. But looks like other strong strongly typed languages do support generic methods in interface. Like, has it using traits. C Sharp and Java have it, of course, because it's easier because everything's an object and whatever.
Shay Nehmad:Swift says they have it, even though it's kind of weird. Cotton, TypeScript, of course. Well, TypeScript is not strongly type. It's like Well, it is strong, but it's strong at the same way that American coffee is strong. Like, coffee.
Shay Nehmad:It's strong, but bad. Goat doesn't have it. It's like stands out. Interesting. But this is an improvement.
Shay Nehmad:Like, this is another step towards being able to write a lot of, generic things. Right?
Jonathan Hall:Right. Which everybody wants. Right?
Shay Nehmad:You painted me as like generic enemy number one, but yeah, I think people want that. We talked about like generic methods, things that are very not concrete. Take us to something very concrete now. Teach me what are struct literals.
Jonathan Hall:Struct literals. So first, what they are and then how they change. Literal encode representation of a struct value, right? Not the type, because you can define a struct, you know, struct person, name, string, age, int or whatever. A struct literal is the representation of that value.
Jonathan Hall:That would be where you say, you know, person colon equals person, curly brace name colon Bob, age colon 23 or whatever. Right? That's a structural 27. 27. Yeah.
Jonathan Hall:Right. What's changed though, is that now if you've embedded something in that struct, so you have a struct embedded in the struct previously, but let's say you embedded
Shay Nehmad:the first and last name, right? Sure. Under this struct called full name?
Jonathan Hall:Right. So you had a full name struct before, and that has the two fields, first name and last name that are both strings. So in the past, if you wanted to do that struct literally, you'd have to copy that whole like first full name literal into that with, like, extra indentation and so on. You no longer have to do that. Now you can reference embedded fields directly in the container.
Jonathan Hall:Is that the right word for the the embedded struct. It makes it makes a lot of that boilerplate. You're if you're if you're using embedded structs a lot, it makes that boilerplate a lot simpler.
Shay Nehmad:What happens if you have, like, collisions? You know, let's say I have ID at the top and ID at the bottom, right? That's that's pretty normal. Let's say if I have I'm trying to embed to, you know, I have one struct that represents something in my DB and another struct that represents something in my DB. And both of these structs have, you know, an ID field and a created at field and an updated at field that are named exactly the same.
Shay Nehmad:How can we with this, you know, like direct reference to embedded fields, how do you deal with that if the field names collide? Won't they, like, collide? Will it pick the second one?
Jonathan Hall:That is a great question, Shay. I'm so
Speaker 4:glad you asked because I had to go
Jonathan Hall:double check my knowledge of this to make sure it was right. But the answer is the shallowest version of that wins. So if you have person with a field called name that embed that also embeds full name that has name, the highest level one, the shallowest one takes precedent.
Shay Nehmad:Okay. So and I can still disambiguate by typing it all out like I used to be able to. That's also Can you?
Jonathan Hall:Yeah. I suppose you can.
Shay Nehmad:Alright. So this is I think, you know, it's gonna save up a lot of typing, but might be a little confusing, which
Jonathan Hall:It should be a little confusing, but embedded structs are already confusing, so That's not to say I don't use them, by the way. I do use
Shay Nehmad:them, My room's but already dirty. What does it matter that I threw another sock on the floor? But, yeah, I don't know. It it stands in stark contrast with the rest of these release notes as something that I'm not sure is actually strictly better than just improving the language, but more of a base choice. And also very weird to me in this day and age to optimize for writability instead of readability.
Jonathan Hall:Well, also uses fewer tokens.
Shay Nehmad:Who I mean, not that who cares? But this is not the thing that you that's gonna save up on your token cost. Know?
Jonathan Hall:Maybe maybe you haven't, just been using enough embedded structs for it to matter.
Shay Nehmad:Okay. So I hate the generics, and now I hate structs. I'm strictly using primitive types in my code. Okay. No, but I mean, they had the we talked about this in the live episode which may have come out already or may come out later, but it was this week, we discussed the blog post from Google Developer Blog where they're like, Go is actually optimized for readability and not for writability.
Shay Nehmad:It's more verbose to have to type out if error is not nil and whatever all the time, but it's actually better both for humans and for agents. This feels like it would be less clear. It's a bit magic y. I don't love it.
Jonathan Hall:Maybe. Although, the other hand, this this is the in my opinion, this is the one place where embedded structs were different because you can already access the fields directly. You don't have to go through that's that's what embedding means. Right?
Shay Nehmad:Yeah.
Jonathan Hall:This is this was sort of a wart. And if we're going to have embedded structs at all, I feel like this was the one place where it wasn't consistent with everything else. So at least it's more consistent now. Whether that's truly an argument in favor of readability or not, I don't know. But at least it's an argument, I think, for consistency.
Shay Nehmad:Okay. I want to take one. Can I tell the people about one? Tell us. Post quantum signatures.
Jonathan Hall:That's why my handwriting looks so bad. It's because it's post quantum.
Shay Nehmad:Yeah. Doctors have been writing my notes, you know, using post quantum cryptography since I was five. What does post quantum mean? So we had the Phipps episode, which I really like. It was very educational
Jonathan Hall:for me.
Alex Scheel:I'm Alex Scheel. I am currently the TSC chair of the Open Battle project in support of Hashimoto Valvass. I'm employed by to work on that project, and I have a lot of fun doing that. Previously, I was at Keyfactor where I worked on the Mount Seacastle cryptographic library, which I'm a go
Shay Nehmad:So we discussed post quantum Phipps in the show in the past. I recommend checking out our episode with Alex Shield. What's the point of having post quantum cryptography given that we don't have quantum computers that work sort of reliably today? Why are we worrying about this now?
Jonathan Hall:Because the stuff you encrypt today might still be around when we do have quantum computers.
Shay Nehmad:Exactly. So this is an interesting concept, but let's say you store very sensitive data with an algorithm that, you know, like normal computers can't crack today, but in five years, quantum computers could. If that data is still relevant to be sensitive in five years, which, you know, medical history
Jonathan Hall:Credit card.
Shay Nehmad:Stuff like that. Yeah. Yeah, like, I don't know, some financial records, law related documents, you know, that are very important, intellectual property, military secrets, like, all these things, you don't want them to be crackable in the future. Specifically, when you're talking about network traffic that goes over the internet, right? Like network traffic that goes over the internet today, if it's encrypted, what you're saying to yourself is, oh, well, it doesn't matter if someone is like, let's say some country that's I'm against, you know, is is listening on the wire under the sea, and duplicating the traffic because it's garbage.
Shay Nehmad:They can't do anything with it. Right? It's encrypted. But if they they store all that traffic and then in five years they can crack it, suddenly it is a real problem that they can listen to all communication. And I think in information security today, there is some assumption that if you send the packet out over the Internet, someone has read it and stored it somewhere.
Shay Nehmad:So if it contains sensitive data, you damn sure want it to be, FIPS compliant or I guess FIPS is the is the, like, American standard, so it doesn't necessarily have to be FIPS compliant, but you want it to be safe post quantum. So that's the need. Now there's the new package CryptoML DSA, which is a post quantum digital signature scheme, which was actually specified in FIPS, like, as part of that standard. And it has three parameter sets, which I don't know what they mean. It's like a44, a67 and a87.
Shay Nehmad:I assume a87 is the better one because it's larger and larger means better. Have you watched, Spinal Tap?
Jonathan Hall:That movie? It's been ages, ages, yeah.
Shay Nehmad:This one goes all the way up to 11. You know what I'm talking about? Why not make 10 the loudest? This one goes to 11. So this one goes to 87.
Shay Nehmad:I have no idea what it means. And it supports, like, you know, private keys and TLS, all these things. So if this is relevant to you, if you're working in like highly regulated industries or
Jonathan Hall:just really
Shay Nehmad:care about encrypting your data, I think this is really relevant. Also one of these things where Go stands out as like, you know, like an enterprise, like software engineering language that actually solves problems for real bit. You know what I mean? Mhmm.
Jonathan Hall:This is
Shay Nehmad:like a mature people thing to solve, if that makes sense. What would you encrypt in post quantum in your life?
Jonathan Hall:Probably just everything. It's not a very interesting answer, but like, why why pick and choose? Just make everything as as secure as possible.
Shay Nehmad:Maybe my flawed transcripts. Like in five years they could be used against me in AI court.
Jonathan Hall:Oh, yeah.
Shay Nehmad:Like what do you mean you called it a clanker? AI jail you go. Alright, so that was the new post quantum signatures. Try like, I think it's a, you know, cool improvement and makes basically go a no brainer if you're working with highly sensitive data.
Jonathan Hall:Cool. Next up, a couple changes to Godoc. Oh. The one I'm most interested in is that you can now specify which version of a package you want to see the documentation for. So we're probably already familiar with the idea of, you know, github.com/foo/bar at whatever version or things like go get.
Jonathan Hall:Now, Go Doc supports the same syntax. So rather than just showing you the documentation, whichever version happens to be installed in that local module, can specify, wanna see this version, then you could easily compare versions, for example. The other
Shay Nehmad:you mean, like, I could run Go doc package, let's say, Logarus 1.7 and then 1.8 and then diff them and see what were the changes in the documentation between these versions.
Jonathan Hall:Or maybe you're running Logris 1.9 and you want to see, oh, Logris 1.10 is out. What's changed? I don't want to have to, you know, commit to to changing it first. I just want to look at the GoDoc first. You could do that.
Jonathan Hall:The other
Shay Nehmad:Straight up, though. Do you look at GoDoc documentation via GoDoc or just the Internet?
Jonathan Hall:Use I both.
Shay Nehmad:Maybe I miss the app or something.
Jonathan Hall:I do both. I usually use the Internet more often, although Claude definitely uses Godoc locally a lot, I've noticed. The other change is a new -ex command, which lets you specify on LinkedIn that you're an ex go developer or an ex oh, wait, no. That's unrelated.
Shay Nehmad:X Google, X whatever, X.
Jonathan Hall:It lets you list the executable examples in a package. So that's probably the one I don't use so much, but it's it's nice to know that it's there if I ever need it.
Shay Nehmad:Wait. So it lets me when I install a package, it will let me know, like, what CLIs I can run now?
Jonathan Hall:No. No. No. So, like, you do a go doc minus ex and then your package name, and it lists the executable examples that might be included in that package.
Shay Nehmad:Oh, executable examples.
Jonathan Hall:Yep.
Shay Nehmad:That's good because that's like the best documentation. Right? When I open GoDoc when I open like a package documentation, my eyes glaze over the like English text because it doesn't matter. And I look for the examples I can click run on because that's like how I learned it. Nice.
Shay Nehmad:Nice. Good improvements. Do you think these improvements were like they came from humans who said, I would love to have this or they came out of, woah, agents could really use this? I
Jonathan Hall:don't know. We should dig into the- I imagine these are mostly human related things, because I don't think agents have a hard time just Googling for a reason.
Shay Nehmad:I give them a hard time all the time. No, but it's interesting because, you know, we've had agents impact the like, agentic development impact how we work and now that it might actually impact how we develop languages. You know what I mean? Mhmm. Cool.
Shay Nehmad:One that I wanted your like, I I'm I'm very excited to hear about is faster memory allocation because anything that makes my software faster without me having to worry about it is like a big plus as far as I'm concerned.
Jonathan Hall:Yeah. So Go one twenty seven has faster memory allocation in in particular for small values at less than 80 bytes. It can it has a new special case function, special case code to allocate that on the the heap more effectively, which has increased performance by about 30% for these types. Now these aren't, of course, necessarily the majority of of data values, but for these types, there is about 30% faster. Estimates are overall to expect about a 1% improvement in memory allocation performance for most programs.
Shay Nehmad:Just for like a general program, even though the bench if you just literally run a benchmark that allocates a ton of really small objects like struct, it will be twice as fast.
Jonathan Hall:Right. Yeah. Right. Right. But most programs aren't doing that.
Jonathan Hall:This does come with a small cost and that is that the runtime is now a little bit larger, about 60 kilobytes larger. So we're trading a little bit of on disk space for faster performance.
Shay Nehmad:I'll take that. It's it makes every Go program that when you compile it, the binary size is larger. Is that what you're saying?
Jonathan Hall:Right.
Shay Nehmad:Oh, can you opt out? I wonder if
Jonathan Hall:you opt out of You can for now. If you want to access that go experiment equals no size specialized malloc. But this is expected to be removed in go 1.28. So it's it's basically if you discover bugs, you can you can opt out of it. It's not meant as a I want slower code so that I have smaller binaries.
Jonathan Hall:That's not the intention.
Shay Nehmad:Not a thing? Maybe this will put you on the spot. I don't know the answer for sure. Well, what's the current size of the runtime?
Jonathan Hall:I don't know. I don't know.
Shay Nehmad:We'll check. Yeah. We're we're cutting here.
Jonathan Hall:Okay, so I just did a quick experiment. I didn't find an official answer for what the runtime size is, and I'm sure it varies a little bit depending on your target operating system and platform stuff. But on my Linux machine with go 126.6, an empty main package, so no imports, does nothing, compiles to about 1.8 megabytes.
Shay Nehmad:So the 60 k is pretty insignificant.
Jonathan Hall:Indeed. Yeah.
Shay Nehmad:Looking for the answer, I found a post in the Go blog from Go one seven, not 27, so 20 versions ago
Jonathan Hall:Ten years.
Shay Nehmad:Where they took the Hello World down from 2.3 megabyte to 1.6 megabyte. So it seems like we stayed pretty good on, like, not adding too much. But anyway, this is obviously a moot point. Like, everybody will prefer to have their software faster for 60 kilobytes of disk space. Like, that's Okay.
Shay Nehmad:An easy Davai, let's talk about goroutines now. Two improvements related to problems with goroutines, which, you know, well, usually my thinking about programming when I teach people programming or when I learn a new programming language, for example, with Rust, is that, like, you learn a programming or a language up to the point where you do concurrency and then, like, you can stop there. And then the leap to doing things, with concurrency is a big leap. It just requires you to think about the program not just in space, but also, like, in time. There's a whole new class of bugs, like deadlocks and whatever.
Shay Nehmad:It just makes things pretty complex. Right? This release has two things that will help you with like managing that complexity of goroutines and finding problems and whatever. The The first one I wanna mention is the goroutine leak profile. What are goroutine leaks?
Shay Nehmad:Help me help our listeners understand. How can goroutines leak? They are not made of water. They're made of bite.
Jonathan Hall:A goroutine leak is essentially a goroutine that never is cleaned up when it should be.
Shay Nehmad:You like open a new
Speaker 4:thread, you know, to use the the easier way to to describe it.
Shay Nehmad:And it's just blocked forever on, a channel and it will never It make might not it might
Jonathan Hall:be blocked or it might just be sitting there, like, idle doing you know, I guess that's blocked. Right? So, yeah, it could just be sitting there waiting for something to happen. It never happens.
Shay Nehmad:Yeah. And, you know, you create a a channel and then it's blocking forever. Nobody will ever receive it. And there is a new, like, option called, goroutine leak in pprof, which if you haven't used it yet I actually gave a lecture on it when we were, like, in Canada on how to use It's these like a superpower. You get all these graphs, all these profiles, whatever for performance.
Shay Nehmad:Usually you would use PPROF to see like where's CPU going? Like what's the hotspot? Why is my program slow? Or where do I allocate the most memory? Talking about like better and faster memory allocation, right?
Shay Nehmad:Whatever. Now it has a new like profiling profile or profiling options. It is actually called a profile, which is complicated enough because I think it's a profile in the is a verb, not as a noun, which will tell you total of leaked goroutines and which line of code leaked it, like which file and which line. So you can, like, define a function called, you know, that does something, inside it you create a channel and then block forever on that channel, like you didn't notice, you didn't pass it back, maybe you did some refactoring or whatever. Now you can just run this profile and and find it, right?
Shay Nehmad:It means it finds go leaked goroutines. Something you would probably wanna do both in your testing and also more importantly, I feel like in production where these problems might add up over time and, you know, they could be the cause of, I don't know, but I don't know why, but every week we have to restart this, server because otherwise it like gets stuck. Know what I mean? Mhmm. Mhmm.
Shay Nehmad:In a real service, you can scrape the slash debug slash pprof slash goroutine leak like endpoint, so you don't have to, you know, run a command or whatever. So you expose that. Just not to the world, just for you. Make sure to not expose it to the world because then they can read all your code, basically. And the second improvement is goroutine labels in tracebacks.
Jonathan Hall:This one this one reminds me of an old package from way back when from Dave Cheney.
Shay Nehmad:Oh, which package?
Jonathan Hall:Junk slash ID. It's a debugging package to to give you the the ID of a running go routine. But the thing that always always makes you remember this is the the description of the package. I'll just read it here on the air. Package ID gives you access to the go routine ID.
Jonathan Hall:If you use this package, you will go straight to hell.
Shay Nehmad:I love it.
Jonathan Hall:The concept here is that you're not supposed to go routines aren't special. You're not supposed to care about the idea of a go routine, so you should treat them as interchangeable is kind of the idea. Yeah. But I I think that anybody who's used this package, maybe they're vindicated now because it's part of the actual go go ecosystem or as part of the the go tool itself. So.
Shay Nehmad:Yes. So first of all, if you're a Go routine and you're listening, don't listen to Jonathan. You're all special. You watch Incredibles. When everybody's special, nobody is.
Shay Nehmad:So the label the label you're supposed to attach to a goroutine shouldn't help you like identify a goroutine. It should help you identify properties about that goroutine. Like, this goroutine handled request ID, whatever. Right? So you can attach It's it to other very like trace style.
Shay Nehmad:If you've done like distributed tracing or con or like contextual loggers or whatever, it's very similar. It's just now it will let you run pprof. Do with pprof. Labels, and then run a thing. And when you run it, you'll see goroutine one.
Shay Nehmad:If you've ever run PPROF output, it says like, goroutine one has done this and goroutine two has done that, or even the race detector, that's how the output looks. Now, next to goroutine one, it's gonna say, you know, oh, request ID, whatever. So you could sort of give the goroutines names, will help you or or properties, I should say, which will help you, like, tell apart. Mostly, I think it's useful for separating two goroutines that do the same work, right? Because their stack price might look the same, but then you could be like, oh, this is doing the work for, John and this is doing the work for Shay.
Shay Nehmad:So goroutine one is Shay's goroutine, you know, you could have a the label by user ID or whatever. And then you'd be able to tell apart these goroutines based on their labels. And because you can have multiple of them if you've ever done like Prometheus or whatever, you can have like multiple dimensions, right? You could be like, okay, I wanna break it down by organization ID, by user ID, by request ID, by, I don't know, a request type, by some parameter. And you could graph like all these things, which is pretty useful.
Shay Nehmad:Although I'm not a 100% sure when I'll use it in pprof. The important part is if you panic or you get a sig quit, you'll also get these annotations, which I think is is is very useful. Like, you get a when you get the trace back of a panic that you didn't expect, you'll know which goroutines did what and it won't just be like a huge sort of unintelligible bunch of goroutine. You can opt out. I don't know why you would.
Shay Nehmad:The only reason you would opt out, I guess, is if the labels might carry sensitive data. So in, you know, it take like the user email or whatever. But you shouldn't do that anyway, even in development. Like you should have opaque IDs you can figure out later. But if you do, you can disable it just because it it is sensitive data that gets written to, like, logs or whatever.
Shay Nehmad:If you use this feature, you might go to hell, you might go to heaven or we all just might die and become trees and there is no afterlife. I didn't see any mention of afterlife or religion in the release notes. Maybe I didn't see them well enough.
Jonathan Hall:Well, if you want to get one step closer to heaven, at least, you could use the new GoFix tool. It's not a new tool, but some new new fixers in the GoFix tool that will make your code a little bit more heavenly. Atomic Types is an analyzer that will modernize your code relying on the legacy sync atomic functions, replace them with atomic types introduced in Go 1.19. So that's been around for a while. We just haven't had this automatic GoFix capability for a while.
Shay Nehmad:Everything GoFix runs is, like, safe. Right? Like, I can run it. It should be the same.
Jonathan Hall:Should be safe. Although it's it's worth pointing out on that note that the existing FMT append f analyzer was removed, although not due to safety concerns, due to stylistic concerns. So I don't know exactly what that did. I don't think I ever used it, but apparently some people didn't like the style.
Shay Nehmad:Yeah, that's fine. I mean, like, what I mean is even though as new versions of Go come out, more modernizers are added to Go fix, I should just always run it, basically, and don't worry about the One thing that's in our backlog is a blog post. Well well, I hope we'll get to it at some point, but people are coming out now with like agent rules or plugins that make sure that agents write more modern code because most of what they've been trained on is old, right? Yeah. So GoFix is another help for that.
Shay Nehmad:That doesn't really cost tokens. It's like fully deterministic, so it's way better. What other modernizers did they add?
Jonathan Hall:Yeah. The other one well, there's there's four new ones. The second one is embed lit, which talks about the first one of the first things we talked about, the new struct literal. It does that for you so you don't have to go through and manually change all your struct literals to use the shorter version. Just run go fix and it'll do it.
Jonathan Hall:Slices backward, which I think should be spelled D R A W K C A B, but, you know, whatever.
Shay Nehmad:Draw kebe.
Jonathan Hall:If you have four loops that count from one minus one to zero in reverse to reverse a slice, it will detect that and switch it for you using slices dot backward. So minor little win there. And then unsafe funcs, it
Shay Nehmad:does It introduces some random one to 10 using the new randn package. And then if it rolls a seven like in Catan, it's going to panic your software.
Jonathan Hall:Yeah. So you asked if if these are all safe. I guess this one's unsafe. Not in that sense, though. It does some pointer arithmetic stuff.
Jonathan Hall:It switches from manual pointer arithmetic to unsafe. Slice.
Shay Nehmad:Oh, okay. Okay. So yeah. I should like if I already have GoFix in my pre commit or, you know, CI or whatever, do I need to do anything to, like, enable these or or deploy these in the same sense that I would need in Golang CLN configuration or stuff like that? No.
Shay Nehmad:It just happens. Right?
Jonathan Hall:Yeah. Just run go fix dot slash dot dot dot, and it will fix your stuff for you.
Shay Nehmad:I mean, you gotta love this release. You you get the modernizers for free, you get 1% performance improvements, you get, like, all these things. You get a new, performance profile for finding leaks without doing any work. You just upgrade the version and you get all this
Jonathan Hall:stuff. Mhmm.
Shay Nehmad:What else do you get as the default version? Very exciting, finally. One of the topics we that that has been with the show for years now.
Jonathan Hall:Yeah. We've been talking about JSON v two for ages. It's been experimental for three or four versions. It's finally official and released. You don't have to do anything except perhaps the old encoding JSON package is now rewritten in terms of encoding JSON v two, which means some error messages have changed.
Jonathan Hall:The the input and output is identical. But if you have tests that pin very specific error message wording, those tests will likely break if you upgrade. But that should be minor. The more important change is that now you have the freedom to use JSON v two, which has some pretty significant improvements, some related to performance and just other capabilities.
Shay Nehmad:The other behavioral change that's really worth noting is that JSON v one assorted Keith.
Jonathan Hall:Oh, yeah. Okay.
Shay Nehmad:And v two does not.
Jonathan Hall:Wait a minute. No. Is that true? Yeah. I think I think you're right.
Jonathan Hall:I'm remembering
Shay Nehmad:It is. That's why they added the json dot deterministic options. Like, you need Okay. Same, like, input, same output bytes for, a golden dataset for tests or something. If you just need if you need a stable map output, you have that.
Shay Nehmad:So there is a way to upgrade and just like, you know, if you wanna be super safe about it, you can just pass JSON deterministic everywhere and then it will other than the error messages, which who cares, It will have exactly the same behavior. Although, of course, it is slower. So And, like, if you have a map, you shouldn't care about order. Maybe you do, but you shouldn't. Oh, no.
Shay Nehmad:The lights are doing the thing again. This is, it not corporeal enough to turn them on, I'm gonna turn them on.
Jonathan Hall:Oh, okay.
Shay Nehmad:So JSON v two, very cool. Also JSON text. What is JSON text?
Jonathan Hall:Yeah. So JSON text is a package that JSON v two is built on that gives you some low level primitives for dealing with JSON stuff if you if you ever need to do that.
Shay Nehmad:So, like, JSON v two is what I'll use in JSON text is like sort of the implementation?
Jonathan Hall:Basically. Speaking of performance improvements, JSON v two is said to be roughly on par with JSON v one for marshaling, but for unmarshaling, it's significantly faster. So So if you have an application that does a lot of JSON unmarshaling, you'll get that for free also just by upgrading because JSON v one is written in terms of JSON v two.
Shay Nehmad:Long time ago, worth, highlighting two, like, old episodes that we from 2023. One with Joe Tsai, episode 34, where we talked about, like, encoding JSON v two.
Alex Scheel:Sure. My name is Joe. I've been working in Go for almost ten years now. I actually started using it close to the one point o release. I would used to be working at SpaceX at the time, and their database telemetry system was written in Go.
Alex Scheel:It was originally written in Python, and then some, engineer comes and says, hey. We should re rewrite this stuff in Go, and that's something.
Shay Nehmad:And another one, episode 36, which was also October 23, where Eliav Laif talked about challenges with, like, parsing JSON quickly.
Speaker 4:So I'm Eliav. I currently live in Tel Aviv, actually, all my life, and I work as a software engineer at Lunar dot dev for a year now. I've done several things before that. I'm also a classically trained musician, So I play the theorbo and the lute.
Shay Nehmad:So, yeah, this issue has been with us for a while. But I'm I'm like, unmarshaling JSONFaster is super important for a ton of really important things. I think there is still place for specialized, like, JSON parsers, you know, that are faster, but maybe this one's just good enough for a lot of cases, you know, handling large messages and whatever. Another very basic thing, so you when you program, you know, web things, right? And not only web things, but, you know, just program stuff in general.
Shay Nehmad:You use JSON, right? You reach for maybe logging, you reach for all these basic things. And in Go up until 01/27, there was one installation I always did, like one package I always had to bring in that was third party, which is of course Testify. No. Oh.
Shay Nehmad:UUID, of course I'm talking
Jonathan Hall:about That's first.
Shay Nehmad:Also, you know, very saltily, a YAML, the hashtag my rejected proposal that I'm still salty about, but fine. But now there's a UID package. Finally, we have a UID package in the standard library, which you can use, you know. Normally, I think you'll just call new v four or new v seven and just get a UID when you need. It's using cryptographically secure random source.
Shay Nehmad:They're comparable. There's, uid dot nil, which is interesting. Uid dot nil will be zero zero across the board. There's uid dot max, which is f's across the board, so like f f f f f f. And when you print them, they're gonna look, you know, as you would expect, like lowercase with dashes and you have UID dot new, which is just like pick whatever algorithm you want.
Shay Nehmad:If you need purely random, you have V four and you have V seven, which I really like, which is time ordered, great for database keys, right? If you do v seven instead of v four, it sorts by creation time really well. So good for like indexing and stuff like that. And yeah, just, prints, gets you random UIDs. Not a lot to say about it other than the fact that the UID package before this proposal, there was like an official ish one, right?
Shay Nehmad:Google slash UID. I think it might be in every Go program, basically. It's a dependency of everything. Right. Yeah.
Shay Nehmad:And there was a big discussion whether it should be UID dot zero, UID dot nil, whatever. But now there's a stable API, you should use it. And in my opinion, you should yank out Google UID, like, don't need that anymore. Obviously, you can do that with a modernizer, but if Go could do it for me, I would do it. Very useful.
Shay Nehmad:Like, Go is basically the only language that doesn't have a built in UID library, and now it has. Do you have any, specific things you can tell me about the Unicode 15 to 17 bump? Because before these release notes, I was not even aware that Unicode has versions. Unicode just has all the characters. So, like, what does it matter?
Jonathan Hall:All the characters? What do you mean? New characters are created all the time.
Shay Nehmad:What is this upgrade? Please explain.
Jonathan Hall:So we've upgraded from Unicode 15 to 17. I guess we decided 16 wasn't sweet enough to to include, so we just skipped that one, jumped straight to 17. But what this means the most important thing this means is that you can now use the new Bigfoot emoji in your emails or Yes. Or your Go program or
Shay Nehmad:Is it new? Wait. Are you kidding? Or is there
Jonathan Hall:literally a There Bigfoot is a Bigfoot emoji. There's a dolphin emoji. There's a, like, exploding cloud electron swarmy thing. There's there's a trump a trombone. There's a bunch of emojis.
Shay Nehmad:Wasn't there always a a dolphin emoji? Am I going crazy?
Jonathan Hall:I don't know. Maybe this is a whale. I don't know what that is. It's a it's an aquatic animal of some sort with fins. Anyway, they added some it's not just emojis.
Jonathan Hall:They added a bunch of, other characters. I'm trying to find the list here. There's a ballet dancer. Where's the actual list here?
Shay Nehmad:Oh, there's root vegetable. It's like a a leek or something. Interesting. I didn't know they they make that many Oh, there's one that's perfect for me in Unicode 16, Face with bags under eyes.
Jonathan Hall:There we go. Yeah. All in all, Unicode 17 adds 4,803 new characters, including some for Saudi Real currency symbol, the Sidetic, an ancient Anatolian script used near is it Seed side in modern day Turkey? Anyway, there's there's a bunch of stuff here. It's not all emojis.
Jonathan Hall:Some of it's for serious uses of archaic languages. Some are even still in use. Berea Eirfeh, a script used for the Zagwaha language in Chad and Sudan. So that's a modern day language. Anyway.
Shay Nehmad:Cool. Man, that script is awesome. Like, these characters look very cool. It's like an upside down A with a little it's cool. Question though.
Shay Nehmad:Okay. So there's a new version of Unicode, has more characters. Why what does the upgrade in Go mean? Does it mean that you couldn't print out these characters? They're just data.
Shay Nehmad:What does the Unicode package actually give you? That's what I'm trying to ask.
Jonathan Hall:Right. So it it that Go now understands these characters, the character classes they belong to, things like that. Go doesn't render these characters, as you were kind of alluding to, right? That depends on your terminal or your web browser or whatever. But Go will know which ones are emojis and which ones are, you know, which character class they belong to, which language it belongs to, and some of this sort of stuff.
Jonathan Hall:Oh, it's So they things like string. To lower will understand these new scripts that, oh, these characters belong to this script, Whereas the new currency symbol isn't a letter, so it shouldn't be uppercase and lowercase and things like that.
Shay Nehmad:Interesting. I wouldn't think about it, but there's a function, for example, isdigit, right?
Jonathan Hall:Mhmm.
Shay Nehmad:You would expect it to just be like, oh, it returns true for one zero through nine, right? But there's I don't know what language this is, like, legitimately don't know, maybe Bangala or something. But the example in the documentation for digit is like a Unicode representation of a number that isn't the way I think of the number three, but it does exist. So it's like making all these functions work with all these new letters, all these new characters, basically. It's part of the standard library, but that means that there's always like a delay between Unicode releases and Go releases.
Shay Nehmad:So there might be a period if your software really relies on a new version of Unicode that you're like sort of stuck. I wonder how you would overcome that if you're actually dependent, like the moment Unicode 18 comes out, you gotta check if something's emoji or not.
Jonathan Hall:Well, so Unicode 15 was released in 2022 and Unicode 16 in 2024. So it's apparently every two years, at least on average for the last last few releases. So, you know, there definitely is a gap, you know, since we Go hasn't updated since 01/15. So we've been four years behind up until now. I guess it's not that serious of a problem or we would have probably solved it sooner in the Go ecosystem.
Shay Nehmad:Yeah. It is like, you know, I'm sure the person who's writing Go servers in what language did you say that was? Ancient Sidetic? They they can, like, hang on for a few moments. Slightly more relevant package, I feel, or technical, I guess, package is the new portable SIMD package.
Shay Nehmad:Not a ton to say about this other than what does SIMD do. So SIMD stands for single instruction, multiple data. And what it does is it lets you in new processors, they come with these new I'll take a step back. Software is compiled to instructions that run on the processor. And in the past, you know, for example, processors were 16 bit, right?
Shay Nehmad:So all the, instructions you could run, like, were 16 bit and all the processor would ship with a manual, like a book. But I I had a few of them in my school's library. I love them. It's like a table of MOV, and MOV, you know, takes these two parameters and it does this, and ADD, which is like add, and JMP, which lets you jump to a specific instruction in memory and whatever. It's like the very low level instructions that the processor runs.
Shay Nehmad:Right? There are new SIMD instructions, right? Again, SIMD stands for single instruction, multiple data, and they are for, like, performance things that now, you know, operator like instructions that these new processors can do, which should help, you know, with like data level parallelism doing a thing in a single command. And, you know, they usually have very specific use cases. You wouldn't reach for this sort of normally, but if you're doing, I don't know, fast string searching or cryptography or signal processing, right, like handling audio blocks or scientific, like matrix multiplications or physics simulations, machine learning.
Shay Nehmad:All these things benefit from SIMD instructions. All of this outside of Go, right? Unrelated. This is a thing that the processors give us. So now there's a SIMD package in the standard library, which gives you like SIMD types and functions and methods for working with these types.
Shay Nehmad:Again, these types are either implemented in hardware or if you don't have them, they're emulated in in pure Go and, you know, it gives you things like get the maximum, element wise of X and Y between two, floats, float 32 s's. Now, if your processor allows you to do that in hardware, it's gonna be super fast, so you'll be able to do that. Multiply, or things like moladd, which takes x, multiplies it with y and adds zed, which is a specific example I like because it really helps you with matrix multiplication or like three d vector analysis. It's like a thing you do all the time. Like multiply X and Y and add a certain Z all the time is something you could do when you're doing like gradient learning training for machine learning.
Shay Nehmad:And if you can do it directly on your hardware, it will be a lot faster. Now this package, you know, is dependent on hardware. So obviously it won't make everything faster. You need the thing that knows how to run it. But if you don't have the thing, let's say you're just running tests, you know, not on your university's hardware with all the, I don't know, Neon 64 ARM, whatever processor, it'll still work.
Shay Nehmad:It'll just be normal go code that will pass to normal instructions instead of the specialized hardware instructions.
Jonathan Hall:So you said that this is for new processors. I thought SIMD had been around for ages. Isn't that what MMX was back in the nineties?
Shay Nehmad:Yeah, I guess, you know, it doesn't mean that it's only for new processors, but it's very it's a very niche optimization and I think it's mostly relevant for, you know, trying to get the max out of what you can. But it obviously, there are some things that you can do on on previous hardware as well. It's not just for new things, but the package The is
Speaker 4:package itself
Jonathan Hall:is new. Yeah.
Shay Nehmad:Yeah. And there's a little, you know, package that actually provides the access to the architecture specific operations low level, which this is all built on called ArchSimd. So architecture specific SIMD instructions, which has things like load a vector from memory. Maybe I I wasn't clear about this. This is all about like vectors.
Shay Nehmad:Yeah? Like you Mhmm. Vector math. That's why this is why this is all like Right. And it checks CPU features, at runtime.
Shay Nehmad:So if you can do some of these things at runtime with your, CPU and it's relying on CPU feature flags. So if your CPU supports AVX, which I think MMX does, then it would work. But if you're trying to deal with higher dimensions like AVX five one two, then old processors won't support it or old hardware won't support it, but new hardware will. That's that's I think where this lands. So you have this like generic package that as a user you'd use and then you have this like low level package which actually maps these all these functions to the hardware, which is very cool.
Shay Nehmad:And if you don't find like, if this package doesn't find it, you know, you'll just use the pure Go. And this is not a portable package. You you never wanna expose these types in public APIs, which is exactly why you have that higher level new. Alright. We're we're we're coming on the end.
Shay Nehmad:We have three final mentions. This is a packed release. Yes. Lots of good stuff.
Jonathan Hall:Is it making you sleepy yet?
Shay Nehmad:Yeah. I wanna I wanna sleep for, a second. But I'm done.
Jonathan Hall:That was a synthetic sleep.
Shay Nehmad:Yes. Unironically, ever since moving to The US, all my sleep is synthetic because I started taking, melatonin.
Jonathan Hall:Oh.
Shay Nehmad:Yeah. I tried to I started taking it to avoid jet lag when I landed because I started working two days after I landed and then ever since then I'm, like, dependent on it for sleep. Probably not a good situation. My medical issues aside, there's a new thing in the sync test package. What is sync test?
Shay Nehmad:Sync.
Jonathan Hall:Yeah. Good question.
Shay Nehmad:Not a sync test, where it's like you audition for X factor, but sync test, like synchronized test package.
Jonathan Hall:Sync test gives you, like, I think they call it a bubble in a test where the clock is frozen and you have more precise control over execution of goroutines and the clock.
Shay Nehmad:Yeah. We talked about this on the show because this is pretty new. It's stable since 01/25. Obviously very useful if you want to test time related things in your unit tests. Now you have synctest.
Shay Nehmad:Sleep, which, is very useful. It's advancing fake time by two seconds or however sorry. It advances fake time by however, how much time you give it, which is very useful to simulate the passage of time, but it has an a very, nice helper that not only it advances the bubble's synthetic clock, it also waits for all the goroutines to settle. So you don't have to call sync test wait anymore. It very naturally, when you read the code, it looks like time actually advanced.
Shay Nehmad:But if you actually run the test, you don't actually have to wait. So if you used to implement these tests by having them in a special file that you run, you know, serially and they take a lot of time because they actually wait, now you can since 01/25, you could do this with a combination of time sleep and sync test weight. And now you can just do sync test sleep, which reads really, really nicely. Yeah. A tiny improvement, but you know, all these timing related things are are very hard, which is why we have the goroutine leak profile and the goroutine labels and all that.
Shay Nehmad:Like you're the like number one proponent of you should have tests for your code, right? So, All all of these
Jonathan Hall:right.
Shay Nehmad:Another test improvement. Lay it
Jonathan Hall:on me. Yes. Yeah. So this is also related to sync test. Up until 01/27, sync test well, even in 01/27, actually, what I'm about to say, sync test will not work if you try to make IO calls.
Jonathan Hall:Network calls, read a file, or it might work. I don't think it works if even if you try to read a file from a disk or something like that. But it certainly doesn't work over the network because you can't just, like, freeze the client to the other side of the network to have them honor your frozen clock and bubble either, which means that if you had any synchronization tests you wanted to do with over HTTP, you were kind of screwed. You had to go fall back to the manual sleeps and whatever other sort of mechanisms you might do. Now, however, the httptest.new test server, the tool you've been using for years to create test servers for tests, has special knowledge of these sync test bubbles and fakes the network when it's in a bubble so that you can do your HTTP client and server tests in a bubble.
Jonathan Hall:And I'm going to use this all the freaking time because I have so many tests like this that in one of my current projects that that I've not been able to sync test.
Shay Nehmad:Yeah. Instead of a TCP connection, now it has an in process pipe. So not only it's aware of sync test blocks and whatever, and not only it's just faster because it does less work, like fewer things, it doesn't need to do a TCP handshake, example, I think you don't have to remember to, like, close it and clean it up and stuff because it doesn't actually allocate any, you know, like, resources.
Jonathan Hall:Yeah. And it and it and it doesn't use an actual TCP socket, which probably doesn't matter in the mass vast majority of cases, but, yeah, just less overhead and keeping things Fewer in things to remember,
Shay Nehmad:fewer things to clean up. And another, like, nice aspect of this, I think it's even if you don't use sync test and whatever, just your tests might go, like, a little bit faster. Right?
Jonathan Hall:Yeah. I suppose in in principle that would be that would make sense. Yes.
Shay Nehmad:Cool. Cool. Cool. Am am I the final one? Oh my god.
Shay Nehmad:How exciting.
Jonathan Hall:Shay, we've we've been hashing out this Go releases for long enough. Do you want to end this on on this note about hashing things out?
Shay Nehmad:Yes. Map slash map hash package has a hasher interface where you can have your own like, the important or the interesting part about it is that you can make your own you can define your own hasher. For example, you can define a case in first of all, can define a hasher that returns the same hash for all values, which does the exact opposite of what hashes usually do and guarantees that you'll have collisions. But more interestingly, you could like modify the data before you hash it in a way that's relevant to you. Let's say you you wanna create hashes for email addresses.
Shay Nehmad:I think that's a very interesting example, right?
Jonathan Hall:Okay.
Shay Nehmad:You wanna make sure that for the same email, get the same hash, right? Naively, you might say, oh, just take the email and hash it, right? Because that's how hashing works. But why would that do do you know why that wouldn't work?
Jonathan Hall:I could think of, like, dictionary attacks or something like that. Is that what you're getting at or is there is there another reason?
Shay Nehmad:No, emails are case insensitive, You know what I mean? So, Fair while technically it's not the same bytes, when you say the same email, what you mean is if I'll send the email to this address, will arrive to that person. Right? So you could define a hasher that's like case insensitive, strips all the plus parts from the end of the host in the email because that doesn't matter, strips all the dots inside the host part because that doesn't matter and strips all the parameters. Emails are super quirky.
Shay Nehmad:It's actually impossible to parse them just with reg ex. It's like really hard.
Jonathan Hall:Yeah.
Shay Nehmad:But if you normalize all the emails, you'll get the same hash. This is obviously something you could always implement yourself, but now you have a Hasher interface where you can plug in like your custom strategy and then do like Hash. Equal or .hash and it will like do the same hash with this generic hashing, comparable hasher like T, right? Or Hasher T, I mean. I'm the the email case is the one that pops out to me as the like most interesting.
Shay Nehmad:I'm not a 100% sure what caused this to go into the language itself. Like there's a long discussion that was kind of hard for me to follow. I think in general, it's part of a bigger op, like process of trying to have more generic collection types, you know, like set of T, map between K and V, the hasher, the map set, ordered maps, heaps, like, you know, just generic, like a binary heap, just generic collection types, which is a larger and longer effort this is a part of. And with that, I think we're done with the things we wanted to highlight, right?
Jonathan Hall:I think so.
Shay Nehmad:And that is a 100% of the commits that went into the release. Right? We haven't missed anything. We
Jonathan Hall:never miss anything. There's quite a bit we haven't talked about. Yeah. We're not going to talk about it all because there's just too much. And even if we just, like, read the whole release notes to you as the episode There's still lot of things
Shay Nehmad:that aren't there. The security releases. I mean, there's almost 2,000 commits between these two versions. You know, a tiny thing. Go test now runs the STD version VetCheck.
Shay Nehmad:And if you're on Windows, crypto now honors the SSL cert directory environment variable. And the time channels are always unbuffered, cut around the last separator, which we actually talked about on the show. And I don't know if that's gonna break your heart, but the Go command dropped support for the bizarre version control system.
Jonathan Hall:Oh, I'm so sad.
Shay Nehmad:Yeah. So many I have
Jonathan Hall:no reason to go learn what that means. Exactly.
Shay Nehmad:So lots of honorable mentions there that, you know, didn't make the cup.
Jonathan Hall:We'll have the full release notes, of course, in the show notes, or you could just Google for them.
Shay Nehmad:Yeah. And highlight worthy thing is that Anton Javanov did the release notes up until now, and
Jonathan Hall:The interactive release notes specifically.
Shay Nehmad:Yeah. Which I really, really liked, because you can click on them and see what they do. This year, he's working on his new language, like the C and the Go style thing and he seems pretty busy and it was just like, ah, I'm not gonna do those anymore. But people have been using his open source project, Bolgodapi to release the Go one hundred twenty seven interactive tour. It was Jesus Espino.
Shay Nehmad:So VictoriaMetrics is hosted there. And I don't know, to me this is the way to read into it and not the actual release notes. This is like better, in my opinion. It's a great format that Anton came up with, and I'm very happy that someone else picked it up, because otherwise I would have.
Jonathan Hall:Awesome.
Shay Nehmad:Alright. So what are your thoughts about this 01/27 release?
Jonathan Hall:I'm happy to use it. I haven't started using it yet. I tried to, and I ran into a problem in my CI pipeline that the dead code tool doesn't yet support the generic methods It may have been fixed by now, but it wasn't fixed as of two or three days ago. So I expect it'll be fixed very soon, and then I'll start using it everywhere. I'm really looking forward to ripping out Google's UUID package.
Shay Nehmad:That's going be a lot of deletions. That's going to be fun.
Jonathan Hall:Yeah. And using the new JSON package are the two things I'm most looking forward to.
Shay Nehmad:I think it's a it's a great the language is not getting more complex, I feel, but there are improvements that, you know, some purists might say like, oh, the all the v two packages, they're actually breaking the Go compatibility promise and blah blah blah. There's a lot of work here to make sure that you're not breaking changes. And yet yet introducing features that would really help you, like implement your software and read your software, improve your software, deploy it to like real customers. And I just love the fact that everything is getting faster and better and it just makes it a no brainer to upgrade compared to, I don't know, Python two versus three or whatever. Like, there's literally zero reason in my opinion not to upgrade your software unless you're like, it's not breaking, it's very easy, it's gonna make everything better, it gives you more options, gives you more profiles, gives you, you know, better packages, can actually help you remove third party dependencies.
Shay Nehmad:So I don't know, just a great release overall. Kudos to the work that the team has put in all around the tooling, the libraries. I'm excited to upgrade. I haven't done so yet, but I will.
Jonathan Hall:Very cool.
Shay Nehmad:All right. We don't have a ad break, but worth mentioning that this show is supported by our beautiful Patreons. We now have a new Patreon tier level. If you're extra rich and wanna give us extra money, we would appreciate it. This is a hobby, we do it for fun, but obviously it costs money to produce and edit and host and all that stuff.
Shay Nehmad:If you wanna join that Patreon or support us in any other way, you can find all the links in cupogo.dev, that is cupogo.dev. Anything else we should mention?
Jonathan Hall:I think that's it.
Shay Nehmad:Yeah, we will have a new, like normal ass episode for y'all next week. Thanks for listening. Program exited. Program exited, goodbye
Creators and Guests
