The newest version of the Go programming language, Go 1.22, has just been released. It brings important changes like fixing a common issue where loop variables were unintentionally shared between iterations and adding the ability to loop over integer values. Alongside these, there are enhancements to the standard library, performance improvements, and more. Check out the release notes for further details here.

Range over integers

There's a new thing the Go team is trying out called "range-over-function iterators". It's a way to work with functions in Go. You can test it by adding GOEXPERIMENT=rangefunc when you build your code.

For more info, you can check out the range-over-function iterators experiment page. There's also an experiment related to SQL ranges available on https://github.com/achille-roussel/sqlrange.

Right now, this feature is not permanent; you have to choose to use it. If it becomes permanent, hopefully, they'll add a way to choose not to use it if it's not common.

You can read more about it in the specification.

New math/rand/v2 package

In Go 1.22, there's a new package called math/rand/v2 in the standard library. You can learn about the differences from the previous version, math/rand, by checking out proposal #61716. The Go team aims to introduce a tool to help migrate APIs in a future release, possibly in Go 1.23.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    randWaitSeconds := rand.Intn(5) + 1
    randDuration := time.Duration(randWaitSeconds) * time.Second
    fmt.Println("Taking a short nap...")
    time.Sleep(randDuration)
    fmt.Println("Ah, refreshed and back on track.")
}

This Go program randomly waits between 1 to 5 seconds, simulating a short nap, then prints "Ah, refreshed and back on track."

The most important changes are as follows:

• No More Read Method

  The Read method, which is now deprecated in math/rand, has not been included in math/rand/v2. However, it's still available in math/rand. If you used to use Read, now you should switch to using crypto/rand's Read instead.

• New Generic N-Function

  The newly introduced generic function N serves a similar purpose to Int64N or Uint64N, but it's designed to work for any integer type.

Better HTTP Routing In Stdlib

In Go, the basic library is usually really good. But for dealing with web pages, the standard library sometimes falls short. Specifically, the part that manages web addresses and methods isn't very flexible.

This means that a certain tool in Go called http.ServeMux can't handle fancy web addresses with extra bits in them, or specify which web actions are allowed.

Some changes have been made to fix this, but they might cause small issues with older code. For example, the way the code handles special characters in web addresses has been improved. If you want to keep using the old way, you can change a setting called httpmuxgo121.

This change is especially useful now because another popular tool called Gorilla Mux might not be reliable in the future.

package main

import (
    "fmt"
    "net/http"
    "net/http/httptest"
)

func main() {
    mux := http.NewServeMux()
    userHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "User ID is %q", r.PathValue("user_id"))
    })
    mux.Handle("/v1/users/{user_id}", userHandler)
    rec := httptest.NewRecorder()
    req := httptest.NewRequest(http.MethodGet, "/v1/users/rajiv", nil)
    mux.ServeHTTP(rec, req)
    fmt.Println(rec.Body.String())
}

The code sets up a simple HTTP server in Go, defines a route /v1/users/{user_id}, and handles requests to this route by extracting the user_id path parameter and responding with a message containing the user ID.

New loop variables

Previously, when using a "for" loop in Go, the variables declared within it were created once and updated with each iteration. This often led to common mistakes such as the loop-goroutine issue, as outlined in the common mistakes documentation. However, with the updated version of Go, each iteration of the loop now generates its own variables, reducing the risk of accidental bugs caused by shared variables. Additionally, "for" loops now have the capability to range over integers, providing developers with more options "for" loop structures.

This change in the behavior of "for" loops only takes effect if the module being compiled declares Go 1.22 or a later version in its go.mod file, ensuring backward compatibility with existing code.

While this adjustment doesn't break the functionality of the "for" loop in Go, it's clear that the previous implementation caused confusion for many developers, leading to numerous bugs throughout the history of Go.

For instance, Let's Encrypt had to revoke 3 million certificates due to a bug related to this issue, as mentioned in their community forum.

Runtime

The latest update to the runtime makes Go programs run faster by 1–3%. It does this by storing garbage collection information closer to the actual data, which reduces the work the computer has to do. This also saves memory by cutting out unnecessary duplicate information.

Compiler

Now, when you use Profile-guided Optimization (PGO), your programs can get faster by 2–14%. This happens because PGO can make smarter decisions about how to optimize your code.

References

https://go.dev/blog/go1.22https://tip.golang.org/doc/go1.22

Conclusion

In summary, Go 1.22 brings important improvements and experimental features to make coding easier and more efficient. From fixing common issues to trying out new ways to work with functions, this update shows how Go keeps getting better. These are the changes I think have been worth mentioning in the newest release of Go. Which new feature do you find most exciting?

Thank you 😊 for taking the time ⏰ to read this blog post 📖. I hope you found the information 📚 helpful and informative 🧠. If you have any questions ❓ or comments 💬, please feel free to leave them below ⬇️. Your feedback 📝 is always appreciated.

Portfolio GitHub LinkedIn Twitter