Welcome, everyone, to the 11th edition of the Go Dev Room.
It's been 11 amazing years, two of which were in the pandemic, we don't count those.
But it's been 11 amazing years.
And as always, we're starting with the state of go,
where we're going to talk about what has changed in the past years
since last two years, one year ago, which was go 1.22.
First of all, we are my, in case you're new here on Omits.
My name is Machia.
I'm a training conductor and training, but that's what's interesting for today.
I'm also a software engineer.
I restylical co-fight, where I work on cloud native security.
And I'm going to talk to you about a few subjects today.
I'm going to talk to you about change in the language.
Change to the new standard library and go.
Change to the go tooling.
As well as an interesting design draft, and of course, a community update.
So you'll be wondering, what has been new since go 1.22?
Of course, go 1.23.
It was released in August 13, 2024, and go 1.24,
which is about to be released in February 2025,
which if you don't realize is starting from today any moment now,
if you're in the go team and have the button press it now.
Nobody, okay, do bad.
Wait a minute, go 1.24.
Means we have been having 25 releases of go 1.0.
Wow.
People, that's 13 years of go 1.0.
If go was a person, it's a teenager, it's going to high school now.
Wow, that's all.
Which follows with the question, is go still that cool new upcoming language we also go learn?
Probably not cool and upcoming.
We should be learning it, but it's not a new fancy thing
that's going to be the next language, because it is the next language already.
So let's talk about anywhere to come in language.
What's anywhere to rest?
Sirius, what are the top programming languages?
And I found better metric than the stack overflow survey or the state of GitHub.
I use the only true metric in the world of programming languages,
which is the size of a dev room and falls down.
This is the go dev room, the past year since 2019 since I had been starting counting this chart.
I didn't want to enter the whole 11 years.
Oh, that's lazy.
Are you seeing our nice chart flowing here between 400 and 600 people?
Let's add a true well tested popular language in the world.
Next to it.
Let's add Python.
We always have been neighbors of Python.
Except for this year, this year we got the bigger size.
We've been Python.
So now let's see where a new up and coming fancy new language.
Also probably learn because it's the best words.
Rust is here.
Rust this year got a very big as dev room.
You can get a falls down.
They went from 170 people to 570 people in their dev room.
Well, congratulations, Rust.
However, 30 years ago I'm going to go learn a lot.
Go learn that we have APIs, the ability of APIs, the ability is important.
You can compile your 30-year-old go-go today and it might still work.
It probably still work.
Officially it should work.
We have a strong standard standard library.
We have everything in the standard library, which you want to use in your life,
in the standard library of your language.
No more choose your framework, stories, standard library.
We have fixed dependency management.
Look some years.
We have fixed it.
We even had generics, which was impossible to think about
13 years ago.
And go even learn to try not to track its users.
Which brings me back to go is a more mature language
than it was 13 years ago.
So what has been changed in this new mature language?
Well, first of all, even in a new year old language,
we still have two major changes to the language.
Which is this year that we can now loop over three new types.
Which is a function, which takes a function, which returns volume,
a function, which returns function, which has a value k,
which returns volume, a function, which contains a function,
which contains k, v, and a Boolean.
What is this nonsense?
It's actually quite simple once you know what it means.
Because I talked about this out here.
The slide from last year is a range-run experiment.
To quickly recap during a range-run experiment,
we have a new interface.
And we have these new ones defined as an interface,
which is Internet Sequence, and Internet Sequence 2,
lack of creative naming.
And what can we do with this?
Well, let's say I have my file struct.
And I want to look over all lines in the file.
We're all the old missing a CSV.
And what I will do is I just take a local copy memory of my data.
And I then return a function, which takes a yield function,
which is a with function in the sequence.
And this one takes a slide of byte, I return the Boolean.
In there, I take my data.
I check, okay, is there still data left?
If so, I take it till the next new line.
I return it to this yields function, which go,
what we give in me, and I test against it.
And then I take the rest of the data.
So this complex structure here.
We go take over in that loop.
And now I have my own lines.
And instead of doing those weird cuttricks,
I can now do range file, a lab file,
that lines, and can range over my files.
You can now easily make your own range functions.
The second new language is that we now have generic type aliases.
When I write that last, because like,
ooh, that's complex.
That's kind of the local slides.
Turns out it's just this.
It's just a generic type.
So now allow it to be used in type aliases.
So for example, I have a set here of p,
which is a comparable.
It's just equal to map p Boolean.
Honestly, I thought this already worked.
Okay.
We now have this in go 1204.
Those were my two new changes to the language,
which takes us to tooling.
And I always talk about govets.
Why do I talk about govets?
Because govets is being run when you run tests.
And if you get that you go versioning your CI,
instead of in your test format,
it might be because of a new govets warning.
And you all will know why.
That's why I'm talking about it.
There are many new warnings in govets.
In go 1.23, it will now warn if you use a function of the standard library
that has been added beyond the function.
Beyond the version, you defined in your go module file.
Very handy.
If now we'll also warn again,
if you don't use any parameters in a printf or any f printing function.
For example, here, this is written by an AI.
Many AIs have made this mistake,
and you haven't corrected them.
So gov will now correct this for you.
If you're now also report,
if you build a parameter in for the patch version,
which is probably what you don't want to do.
If you're now also report more issues
in the declarations of tests,
further benchmark and example code.
Let's look forward to go come out.
And I'm introducing a new category,
which is the CI life changes.
This new changes will change your life in the CI forever.
First of all, go to link now support JSON output.
We have go test, minor JSON, go in some minor JSON,
and go build minor JSON.
Yes, JSON output, parsable, logging,
collecting knowledge and elastic search, perfect.
How does this work?
Well, I'm working on this co-fight as decating,
and of course, I'm a coot developer.
I write tests.
So I run my tests.
As we all do, we go test.
And I have here okay, okay, okay.
If I want to cause metrics out of this for my CI,
I can do a magic part on the word okay.
That's going to be very complex.
Or can use this new JSON output,
which will output something like this.
The exact time output, which package has been built,
the exact test has been run on this,
and the output test has just passed.
Okay, the output is still somewhere to do.
At least we now have JSON parsable outputs.
Well, I'm also building my co-fight CTL.
Well, yeah, binary.
So I'm doing this.
And we all know if you do co-ocolon build,
and if you succeed, we don't have outputs.
We're all used to that.
What do you get if you do co-ocolon build,
there's JSON?
Well, your output is, nothing.
Maybe not useful if you want to pass locks.
Still output something.
Another big change is that goes set the binary version
based on your version control system.
Really? No, boss?
Wow.
13 years for this basic feature.
What we're going to do?
Well, let's set the version in your binary,
based on your tag and or commits.
It will add a dirty suffix if you have a committed changes.
Of course, you can disable it with this build flag.
How does this work?
We have all done this before in our lives.
We added a dirty variable somewhere
or gives environment variables of some crazy tricks.
How do we do this now?
We have here my main function,
of which I call the debug package.
And I fetch the read build info.
I handle my error.
I'm a good developer.
And I print out my version number.
So I have this.
So I wrote this program.
It doesn't work from goal run by the way.
Only on goal build.
I do goal build and I run my program.
My output version is empty.
I forgot getting it.
Mark anyway.
What do I do whenever getting it?
I get my version is development.
Oh, I forgot to commit my changes.
I commit my changes.
I write a very good commit message.
And I get the version number with the current build date
and the get shot.
Perfect.
What do I do when I get it?
I get the version.
We try to act.
V0.1.0.
My build now finally without any dirty tricks in your CI
has the build version built in.
There is also the new book goal tool directive.
If you're using terpory libraries for goal generation,
the open API library, you previously had to define
them in the goal model file as an actual dependency,
which is not correct because you're not
depending on that code.
So there is now this dash tool flag.
Right here in the goal gets.
And you can then,
project tool will be saved in the tool
right in the goal module file.
And you can use it with the goal tool commands
and goal goal on general rate will automatically use this.
Very handy for any build dependencies.
Now let's look at the goal command.
What's been new apart from CI lab changes?
There was a big change to goal telemetry.
And if I'm giving this talk at false them,
the community which is about all about open data, transparency,
no tracking, no tracing.
And I'm talking about goal telemetry.
This is controversial.
Oops.
And yes, it's controversial.
I looked at that.
They started back in 2023.
And the first thing I could find on hacker news
at 234 comments.
I read them all.
No, it didn't.
Even that hidden on hacker news,
the register picked it up with the name
subline.
That's devs do not trust mountain view.
Wow.
It's mainstream.
That media picks up on a program in line
which is terrible.
So goal makes telemetry opt in only.
We should of course result to the
contradicting post by goal making my making telemetry opt in.
It wasn't mistake.
And again, theta by hacker news,
300 comments and people were angry again.
So what is magical to say on stage for 25?
First of the clear,
I am not involved with the goating.
I am not working at Google.
I do not have any involvement in this.
So please do not kick me.
The good news is,
it is still opt in.
Phew.
We now have an easy way to opt in.
We just go telemetry on and go telemetry off.
What has been changed?
There is a new design.
Fancy, more efficient.
And it will now automatically,
even if you did not enable,
store data locally.
For, okay, it crashes.
You can use this with telemetry data in about report.
There will be data on your desk.
It will not be sent.
Don't be scared.
That's what is new.
There are also desk technology prompts.
If you use Visual Studio Code and you are in the lucky 2%
which you roll out,
you will now get a friendly notice.
It will only enable telemetry.
Only 100 people enable this.
We need more.
So you now have this bag in prompts.
And why did they put this bag in prompts?
Because the go-to truly believes that telemetry
will drive their stability forward.
This is a quote by the go-to-f team in a blog post about this.
Go-turns 15 this November.
And both the language and the ecosystem continue to grow.
Telemetry will play a critical role in helping go-contributes
move faster and more safely in the right direction.
They truly believe that telemetry will help them.
It is still your own choice to label a lot.
I want if you want to.
You can do so.
That was the go tooling.
Now let's talk about the standard library.
Now usually a few very interesting changes in there.
Last year I introduced these lies in max package.
Thanks to genetics.
Well we now have this either interface.
So we now have helper functions for iterations.
We have all key values in search for it.
For example, I have your slice with three random names.
And I want to look over it backwards.
In the past, I would have to do credit tricks like reversing the
length or reversing everything and doing weird tricks.
I can now just use slices.backwards, names and range over it.
So we have a lot of helper functions thanks to this new
range from experiments.
And as you would suspect, it will return nicely
than in backwards order.
That also means very welcome yay security changes.
The treaty aside for what's removed.
Yay security.
If you had been using it, it is a breaking change for you.
If you have been using it, stop so now.
More security.
We now have supports in 1.24 for the encrypted client hello in
the LATAN checks.
As well as quantum proof key exchanges.
Yay security.
More yay security.
The RSA package will now break.
If you ask the key, less than 10, 24 bits.
Which again, you shouldn't be doing.
If you do so, this is a breaking change and stop doing that.
More cryptoneuse.
HQDF.
TBKF2.
As the HH3 moved from the experiment to critical library to the
stable library.
Yay security.
Also, we now have a new package which
will complement the 503 key exchange with quantum proof key
exchanges.
More yay security.
It is in the OS package.
Are you tired of this classic attack,
where somebody enters dot dot slash dot dot slash dot
slash dot dot slash dot slash dot slash dot slash
slash slash EDC passwords in your application.
We will see is guilty of warranty such an application.
Oh, nobody wants to admit it.
We all have done this.
It's a very easy attack.
It happens on every IoT device.
No worries.
Go got a fixed after 13 years.
You're stuck in 30.
What do they now have?
Is the OS dot open root function.
Which gives you a secure root and own and
doesn't allow any backwards movement into the file
system.
It's even that secure.
It protects you against symbolic links out of
this specific root.
Are you dealing with files that you just upload a user
can access in your go application.
Switch to open root right now.
It's also been a change at the CP package.
Go now support the multi-party CP flag on the
left and enable it by default.
What is multi-party CP?
That's everybody but the network engineer right there.
We implemented.
Well, this is an RFC thing that depends it's simple.
You can now have the TCP flow go over multiple
network interface and multiple parts of the internet.
Why should you care as developer?
Well, mobile network targeting.
Even fallback to mobile network targeting.
Also, you can use multiple parts for better performance.
Also, TCP will stay active over any IP changes.
Oh, it's just super cool.
The JSON package now also has a new omit zero flag,
which is just like omit empty but for the zero value.
I have an example, or I have a transition.
I have a name and if it's empty, I want to
omit it in my JSON module output.
We all do this.
But I also have a UIC code, which is an integer.
An integer cannot be empty.
But it can be zero.
And a UIC code is probably never zero.
So I just do omit zero.
Same thing, I have a date, an opening date of the station right there.
I can now omit zero if the station opens at the gear zero,
which I hope it doesn't.
We're also talking about time.
There is a brick and change in the parts and
parts and location function and go.
If you know, we submitted the time zone that doesn't exist,
it will add or.
More about time, there is also a new thing test
and run experimental package.
This one will run your test in a time bubble.
We'll run your gorethins in a time bubble with a fake
clock, which if you have code at a present time,
it's very handy.
It's still experimental.
We have one new package in the standard library,
which is the unique package.
Which can not recognize its value for faster comparison.
It's a very fancy way if you want to impress your partner
to more way, connect, I learned about
the organization of failures across the comparisons.
Which is actually quite simple,
once you put it into practice.
I have two very complex trucks.
They both contain a number.
And I want to compare those two.
How could I compare those two right now?
Very hard.
Well, with the unique package,
I can just make them unique values.
I do unique that makes that one and unique.
Let's try to make two.
And you can get it.
I can just compare.
If you two equals wheel one,
is the same.
Super simple to compare your very complex trucks.
Now, let's talk about changes to go runtime.
First of all, time the timer and then the ticker
now will be gobbish collect,
even if you didn't cancel it.
If you forgot to cancel your timer,
it will be coverage collected if there are no more references.
Go also, implement Swiss maps.
And gosh, I am an expert of Swiss-related on maps.
Just a wrong kind of Swiss maps.
If you want to try to play your train travel in Switzerland,
yeah, come to me.
But I don't know zero shit about official ghost
with maps.
Coating Brian Board, I'm in the room.
And it will come back at 11.30 to give you an in-depth view
about how Swiss maps are the new amazing thing
and go that makes your applications go faster.
That causes speed.
We have two to three percent faster on the average
go benchmarks, yeah speed.
Most of you thank you Swiss maps and the new unique
implementation.
Now, let's take a look at goports as the last technical subject.
Go 1.23 at six experimental supports for OpenVSD
on the risk five, 64 bit per four.
And one guy right in the back is very excited about this, I see it.
Go 1.25 will require macOS 12, all later.
Go 1.24 has no support for Windows R32 bits,
which is only the Windows R key tablet.
For obvious back which they kind of fix.
It just is broken, don't try it right now.
There also have this on well, we'll change it to WebAssembly.
We now have a WASMAX course function,
which can export you from the function to WebAssembly host.
We also now import allow more data types
to be imported with a WASMAX port.
But again, I go the next part of that is.
At 4pm I will have a talk here by Eduardo is
which is about WebAssembly for GoFresh,
which will take you to all things I just said just to way better.
And there also have these changes to the Linux port in Go.
Wait, what?
I never have changed the Linux port.
Never.
Well, go 1.23 will be the last release of supports.
The Linux kernel 2.6.30 to your later.
The Linux developer is now looking very like,
wow, that's released in 2010.
Yes.
Go support a kernel that's basically older than itself.
Because I've read that.
Go 1.24 will now require 3.20 later,
which was released just in 25.
They deprecate a macOS version
which was released yesterday.
But the next version is still table 21.
We all know where Go runs most, right?
So that has been the new updates to go.
What's there for the future of Go?
I always looked through some design drafts,
which is going to be put in together,
and want to find something interesting.
This year I found one very interesting thing,
which is the concept of memory regions,
which builds on a lot of early expansion
with the goal to reduce the risk of cost of garbage collection,
and return more controlled developers,
just like in Rust.
It's built on an early proposal,
which was the arena package.
What does this thing do in very simple terms?
I have a function,
and I am a developer who works with very big complex prototypes.
My job I work with very big complex prototypes.
And I have my region, and I will parse my very big complex prototypes,
which takes a lot of memory with the very big complex prototypes.
So I am marshallet,
but all the program cares actually just if it errors or not.
Okay, so I will set this top level error,
which is my function here above on my screen.
Done, perfect.
Why is this more efficient now?
Once this feature is released,
once this region functions ends,
my function in region.do,
it immediately removes our memory without having to run garbage collection,
which gives me control over my memory,
and it's way more efficient.
Another example is I define a bunch of new variables,
meaning immediately assigned use,
whatever types I only want to keep the results,
once this function exits,
I now have returned all the memory,
read out to in the complex garbage collection mask.
It just removes the whole region.
It gives us the developers complete control over our memory.
Is this more efficient?
Of course, the go down run with a few tests.
They tested against co-crojDB and SCD,
jabbo databases,
which located a lot of memory.
And they found the 5% improvement in time
in the garbage collector,
and even a 2% to 1% improvement in time,
using allocations spent less than before.
These are still early tests.
This is a really handy feature,
and maybe we see it next year, maybe we will never see it.
If you are interested in this,
this long-lange,
and I will post it on the fourth on website later,
has all information about this.
There was even a very interesting implementation details,
which I don't have time to talk about today,
but it's also pretty interesting.
And at last, I want to talk about my favorite objects,
the co-community.
I haven't met here of all go-beats in the world,
which is used to be more,
but the general meat of community is just way less active
than people in them.
It's just a true fact.
Do we move going go-beats meet-ups,
are still stable around 41 chapters,
with the thing that many of those chapters
are currently inactive,
it's just hard to define which numbers these are.
But I like the frozen community the most.
You all here in this room.
We've been here for 11 years,
and I clicked too fast,
and now the Wi-Fi is loading my slides.
And the time is ticking away.
And so I'm going to talk about how Google slides
is a very amazing product by the people of Google,
which never blocks even on bad Wi-Fi.
There it is.
Yep, 2017, and loading again.
Again, Google slides are an amazing product.
Maybe I should have used an open source solution.
It's small images, maybe.
I don't know.
Small images suck.
Come on, Google.
Wow.
Yes, please.
Show anyway.
Thank you.
Last year, we came from last year for yourself.
I can.
And this year, we have an AI chat box.
Our blockchain support got removed.
And I am pretty nervous.
This amazing schedule, which, by the way,
is 100% billion average.
If any of you happen to be working on a billion,
you can just quickly come give me a donation of a million dollars
to have the code for next year.
So this is our main schedule.
I really had to reject amazing talks.
I wish I had two days.
Well, actually don't, because it's too heavy.
And I made this year, I made five tracks.
The first one is about go.
And now that we're all fresh and not yet drunk,
we have an hour of deep dives.
Very deep that even talks about the inner workings of go.
We will slowly transition out of it.
And I will go to from 13, 13, 16,
we will have talks about using go.
Using go better, using go in different projects.
And from 16, 30 to 18 o'clock,
we will have the one and two tiny go conference.
And the most interesting hour is the last one,
which is all about you, about the lightning talks.
Submit one.
I see you all got a taste of go conferences.
Well, well, that's an interesting go conference to go to.
At the go, definitely force them.
Very interesting, please say.
Quite amazing talks.
If you want to travel to Latin America,
you can do go for go for go in Latin America Brazil in May.
Go for go on Europe for the health in Berlin this year.
In June.
And go for go in Europe this year on August.
Lightening talks.
And again, the last hour of the day is about lightning talks,
which will be eight minutes of talks this year.
And the CFP will be open to five feet,
which is one hour before the talks,
which will quickly notify you if you had been accepted.
How you submit one?
You go to go for the last slash light.
Oh, you scan one of the QR codes in this room.
You have to be at force them to submit one.
Don't submit one if you're watching home from your computer.
Do not do that.
So you can submit a talk for lightning talks
and get eight minutes of this amazing stage here
to prove how awesome you are.
And I can all see that each and every one of you is awesome.
You can follow us on social media.
You can post about us on social media.
And if you do, please do so.
And use the hashtag hashtag for them.
You can follow us on the Fediverse.
And you can also follow us on our blue sky bridge.
You can not follow us on X for very obvious reasons.
That was my talk for today.
Thank you very much for enjoying this.
And I see you all of the fall.
See you next year.
Thanks for watching.