4.7 KiB
| title | date | by | summary | |
|---|---|---|---|---|
| Go 1.6 is released | 2016-02-17 |
|
Go 1.6 adds HTTP/2, template blocks, and more. |
Today we release Go version 1.6, the seventh major stable release of Go. You can grab it right now from the download page. Although the release of Go 1.5 six months ago contained dramatic implementation changes, this release is more incremental.
The most significant change is support for HTTP/2 in the net/http package. HTTP/2 is a new protocol, a follow-on to HTTP that has already seen widespread adoption by browser vendors and major websites. In Go 1.6, support for HTTP/2 is enabled by default for both servers and clients when using HTTPS, bringing the benefits of the new protocol to a wide range of Go projects, such as the popular Caddy web server.
The template packages have learned some new tricks,
with support for trimming spaces around template actions
to produce cleaner template output,
and the introduction of the {{raw "[{{block}} action]"}}(/pkg/text/template/#hdr-Actions)
that can be used to create templates that build on other templates.
A new template example program demonstrates these new features.
Go 1.5 introduced experimental support for a “vendor” directory that was enabled by an environment variable. In Go 1.6, the feature is now enabled by default. Source trees that contain a directory named “vendor” that is not used in accordance with the new feature will require changes to avoid broken builds (the simplest fix is to rename the directory).
The runtime has added lightweight, best-effort detection of concurrent misuse of maps. As always, if one goroutine is writing to a map, no other goroutine should be reading or writing the map concurrently. If the runtime detects this condition, it prints a diagnosis and crashes the program. The best way to find out more about the problem is to run it under the race detector, which will more reliably identify the race and give more detail.
The runtime has also changed how it prints program-ending panics. It now prints only the stack of the panicking goroutine, rather than all existing goroutines. This behavior can be configured using the GOTRACEBACK environment variable or by calling the debug.SetTraceback function.
Users of cgo should be aware of major changes to the rules for sharing pointers between Go and C code. The rules are designed to ensure that such C code can coexist with Go's garbage collector and are checked during program execution, so code may require changes to avoid crashes. See the release notes and cgo documentation for the details.
The compiler, linker, and go command have a new -msan flag
analogous to -race and only available on linux/amd64,
that enables interoperation with the
Clang MemorySanitizer.
This is useful for testing a program containing suspect C or C++ code.
You might like to try it while testing your cgo code with the new pointer rules.
Performance of Go programs built with Go 1.6 remains similar to those built with Go 1.5. Garbage-collection pauses are even lower than with Go 1.5, but this is particularly noticeable for programs using large amounts of memory. With regard to the performance of the compiler tool chain, build times should be similar to those of Go 1.5.
The algorithm inside sort.Sort
was improved to run about 10% faster,
but the change may break programs that expect a specific ordering
of equal but distinguishable elements.
Such programs should refine their Less methods to indicate the desired ordering
or use sort.Stable
to preserve the input order for equal values.
And, of course, there are many more additions, improvements, and fixes. You can find them all in the comprehensive release notes.
To celebrate the release, Go User Groups around the world are holding release parties on the 17th of February. Online, the Go contributors are hosting a question and answer session on the golang subreddit for the next 24 hours. If you have questions about the project, the release, or just Go in general, then please join the discussion.
Thanks to everyone that contributed to the release. Happy hacking.