Go 1.2 Release Notes

Introduction to Go 1.2

Since the release of Go version 1.1 in April, 2013, the release schedule has been shortened to make the release process more efficient. This release, Go version 1.2 or Go 1.2 for short, arrives roughly six months after 1.1, while 1.1 took over a year to appear after 1.0. Because of the shorter time scale, 1.2 is a smaller delta than the step from 1.0 to 1.1, but it still has some significant developments, including a better scheduler and one new language feature. Of course, Go 1.2 keeps the promise of compatibility. The overwhelming majority of programs built with Go 1.1 (or 1.0 for that matter) will run without any changes whatsoever when moved to 1.2, although the introduction of one restriction to a corner of the language may expose already-incorrect code (see the discussion of the use of nil).

Changes to the language

In the interest of firming up the specification, one corner case has been clarified, with consequences for programs. There is also one new language feature.

Use of nil

The language now specifies that, for safety reasons, certain uses of nil pointers are guaranteed to trigger a run-time panic. For instance, in Go 1.0, given code like

type T struct {
    X [1<<24]byte
    Field int32
}

func main() {
    var x *T
    ...
}

the nil pointer x could be used to access memory incorrectly: the expression x.Field could access memory at address 1<<24. To prevent such unsafe behavior, in Go 1.2 the compilers now guarantee that any indirection through a nil pointer, such as illustrated here but also in nil pointers to arrays, nil interface values, nil slices, and so on, will either panic or return a correct, safe non-nil value. In short, any expression that explicitly or implicitly requires evaluation of a nil address is an error. The implementation may inject extra tests into the compiled program to enforce this behavior.

Further details are in the design document.

Updating: Most code that depended on the old behavior is erroneous and will fail when run. Such programs will need to be updated by hand.

Three-index slices

Go 1.2 adds the ability to specify the capacity as well as the length when using a slicing operation on an existing array or slice. A slicing operation creates a new slice by describing a contiguous section of an already-created array or slice:

var array [10]int
slice := array[2:4]

The capacity of the slice is the maximum number of elements that the slice may hold, even after reslicing; it reflects the size of the underlying array. In this example, the capacity of the slice variable is 8.

Go 1.2 adds new syntax to allow a slicing operation to specify the capacity as well as the length. A second colon introduces the capacity value, which must be less than or equal to the capacity of the source slice or array, adjusted for the origin. For instance,

slice = array[2:4:7]

sets the slice to have the same length as in the earlier example but its capacity is now only 5 elements (7-2). It is impossible to use this new slice value to access the last three elements of the original array.

In this three-index notation, a missing first index ([:i:j]) defaults to zero but the other two indices must always be specified explicitly. It is possible that future releases of Go may introduce default values for these indices.

Further details are in the design document.

Updating: This is a backwards-compatible change that affects no existing programs.

Changes to the implementations and tools

Pre-emption in the scheduler

In prior releases, a goroutine that was looping forever could starve out other goroutines on the same thread, a serious problem when GOMAXPROCS provided only one user thread. In Go 1.2, this is partially addressed: The scheduler is invoked occasionally upon entry to a function. This means that any loop that includes a (non-inlined) function call can be pre-empted, allowing other goroutines to run on the same thread.

Limit on the number of threads

Go 1.2 introduces a configurable limit (default 10,000) to the total number of threads a single program may have in its address space, to avoid resource starvation issues in some environments. Note that goroutines are multiplexed onto threads so this limit does not directly limit the number of goroutines, only the number that may be simultaneously blocked in a system call. In practice, the limit is hard to reach.

The new SetMaxThreads function in the runtime/debug package controls the thread count limit.

Updating: Few functions will be affected by the limit, but if a program dies because it hits the limit, it could be modified to call SetMaxThreads to set a higher count. Even better would be to refactor the program to need fewer threads, reducing consumption of kernel resources.

Stack size

In Go 1.2, the minimum size of the stack when a goroutine is created has been lifted from 4KB to 8KB. Many programs were suffering performance problems with the old size, which had a tendency to introduce expensive stack-segment switching in performance-critical sections. The new number was determined by empirical testing.

At the other end, the new function SetMaxStack in the runtime/debug package controls the maximum size of a single goroutine’s stack. The default is 1GB on 64-bit systems and 250MB on 32-bit systems. Before Go 1.2, it was too easy for a runaway recursion to consume all the memory on a machine.

Updating: The increased minimum stack size may cause programs with many goroutines to use more memory. There is no workaround, but plans for future releases include new stack management technology that should address the problem better.

Cgo and C++

The cgo command will now invoke the C++ compiler to build any pieces of the linked-to library that are written in C++; the documentation has more detail.

Godoc and vet moved to the go.tools subrepository

Both binaries are still included with the distribution, but the source code for the godoc and vet commands has moved to the go.tools subrepository.

Also, the core of the godoc program has been split into a library, while the command itself is in a separate directory. The move allows the code to be updated easily and the separation into a library and command makes it easier to construct custom binaries for local sites and different deployment methods.

Updating: Since godoc and vet are not part of the library, no client Go code depends on their source and no updating is required.

The binary distributions available from golang.org include these binaries, so users of these distributions are unaffected.

When building from source, users must use “go get” to install godoc and vet. (The binaries will continue to be installed in their usual locations, not $GOPATH/bin.)

$ go get code.google.com/p/go.tools/cmd/godoc
$ go get code.google.com/p/go.tools/cmd/vet

Status of gccgo

We expect the future GCC 4.9 release to include gccgo with full support for Go 1.2. In the current (4.8.2) release of GCC, gccgo implements Go 1.1.2.

Changes to the gc compiler and linker

Go 1.2 has several semantic changes to the workings of the gc compiler suite. Most users will be unaffected by them.

The cgo command now works when C++ is included in the library being linked against. See the cgo documentation for details.

The gc compiler displayed a vestigial detail of its origins when a program had no package clause: it assumed the file was in package main. The past has been erased, and a missing package clause is now an error.

On the ARM, the toolchain supports “external linking”, which is a step towards being able to build shared libraries with the gc toolchain and to provide dynamic linking support for environments in which that is necessary.

In the runtime for the ARM, with 5a, it used to be possible to refer to the runtime-internal m (machine) and g (goroutine) variables using R9 and R10 directly. It is now necessary to refer to them by their proper names.

Also on the ARM, the 5l linker (sic) now defines the MOVBS and MOVHS instructions as synonyms of MOVB and MOVH, to make clearer the separation between signed and unsigned sub-word moves; the unsigned versions already existed with a U suffix.

Test coverage

One major new feature of go test is that it can now compute and, with help from a new, separately installed “go tool cover” program, display test coverage results.

The cover tool is part of the go.tools subrepository. It can be installed by running

$ go get code.google.com/p/go.tools/cmd/cover

The cover tool does two things. First, when “go test” is given the -cover flag, it is run automatically to rewrite the source for the package and insert instrumentation statements. The test is then compiled and run as usual, and basic coverage statistics are reported:

$ go test -cover fmt
ok      fmt 0.060s  coverage: 91.4% of statements
$

Second, for more detailed reports, different flags to “go test” can create a coverage profile file, which the cover program, invoked with “go tool cover”, can then analyze.

Details on how to generate and analyze coverage statistics can be found by running the commands

$ go help testflag
$ go tool cover -help

The go doc command is deleted

The “go doc” command is deleted. Note that the godoc tool itself is not deleted, just the wrapping of it by the go command. All it did was show the documents for a package by package path, which godoc itself already does with more flexibility. It has therefore been deleted to reduce the number of documentation tools and, as part of the restructuring of godoc, encourage better options in future.

Updating: For those who still need the precise functionality of running

$ go doc

in a directory, the behavior is identical to running

$ godoc .

Changes to the go command

The go get command now has a -t flag that causes it to download the dependencies of the tests run by the package, not just those of the package itself. By default, as before, dependencies of the tests are not downloaded.

Performance

There are a number of significant performance improvements in the standard library; here are a few of them.

• The compress/bzip2 decompresses about 30% faster.
• The crypto/des package is about five times faster.
• The encoding/json package encodes about 30% faster.
• Networking performance on Windows and BSD systems is about 30% faster through the use of an integrated network poller in the runtime, similar to what was done for Linux and OS X in Go 1.1.

Changes to the standard library

The archive/tar and archive/zip packages

The archive/tar and archive/zip packages have had a change to their semantics that may break existing programs. The issue is that they both provided an implementation of the os.FileInfo interface that was not compliant with the specification for that interface. In particular, their Name method returned the full path name of the entry, but the interface specification requires that the method return only the base name (final path element).

Updating: Since this behavior was newly implemented and a bit obscure, it is possible that no code depends on the broken behavior. If there are programs that do depend on it, they will need to be identified and fixed manually.

The new encoding package

There is a new package, encoding, that defines a set of standard encoding interfaces that may be used to build custom marshalers and unmarshalers for packages such as encoding/xml, encoding/json, and encoding/binary. These new interfaces have been used to tidy up some implementations in the standard library.

The new interfaces are called BinaryMarshaler, BinaryUnmarshaler, TextMarshaler, and TextUnmarshaler. Full details are in the documentation for the package and a separate design document.

The fmt package

The fmt package’s formatted print routines such as Printf now allow the data items to be printed to be accessed in arbitrary order by using an indexing operation in the formatting specifications. Wherever an argument is to be fetched from the argument list for formatting, either as the value to be formatted or as a width or specification integer, a new optional indexing notation [n] fetches argument n instead. The value of n is 1-indexed. After such an indexing operating, the next argument to be fetched by normal processing will be n+1.

For example, the normal Printf call

fmt.Sprintf("%c %c %c\n", 'a', 'b', 'c')

would create the string "a b c", but with indexing operations like this,

fmt.Sprintf("%[3]c %[1]c %c\n", 'a', 'b', 'c')

the result is “"c a b". The [3] index accesses the third formatting argument, which is 'c', [1] accesses the first, 'a', and then the next fetch accesses the argument following that one, 'b'.

The motivation for this feature is programmable format statements to access the arguments in different order for localization, but it has other uses:

log.Printf("trace: value %v of type %[1]T\n", expensiveFunction(a.b[c]))

Updating: The change to the syntax of format specifications is strictly backwards compatible, so it affects no working programs.

The text/template and html/template packages

The text/template package has a couple of changes in Go 1.2, both of which are also mirrored in the html/template package.

First, there are new default functions for comparing basic types. The functions are listed in this table, which shows their names and the associated familiar comparison operator.

	Name	Operator
	eq	==
	ne	!=
	lt	<
	le	<=
	gt	>
	ge	>=

These functions behave slightly differently from the corresponding Go operators. First, they operate only on basic types (bool, int, float64, string, etc.). (Go allows comparison of arrays and structs as well, under some circumstances.) Second, values can be compared as long as they are the same sort of value: any signed integer value can be compared to any other signed integer value for example. (Go does not permit comparing an int8 and an int16). Finally, the eq function (only) allows comparison of the first argument with one or more following arguments. The template in this example,

{{if eq .A 1 2 3}} equal {{else}} not equal {{end}}

reports “equal” if .A is equal to any of 1, 2, or 3.

The second change is that a small addition to the grammar makes “if else if” chains easier to write. Instead of writing,

{{if eq .A 1}} X {{else}} {{if eq .A 2}} Y {{end}} {{end}}

one can fold the second “if” into the “else” and have only one “end”, like this:

{{if eq .A 1}} X {{else if eq .A 2}} Y {{end}}

The two forms are identical in effect; the difference is just in the syntax.

Updating: Neither the “else if” change nor the comparison functions affect existing programs. Those that already define functions called eq and so on through a function map are unaffected because the associated function map will override the new default function definitions.

New packages

There are two new packages.

• The encoding package is described above.
• The image/color/palette package provides standard color palettes.

Minor changes to the library

The following list summarizes a number of minor changes to the library, mostly additions. See the relevant package documentation for more information about each change.

• The archive/zip package adds the DataOffset accessor to return the offset of a file’s (possibly compressed) data within the archive.
• The bufio package adds Reset methods to Reader and Writer. These methods allow the Readers and Writers to be re-used on new input and output readers and writers, saving allocation overhead.
• The compress/bzip2 can now decompress concatenated archives.
• The compress/flate package adds a Reset method on the Writer, to make it possible to reduce allocation when, for instance, constructing an archive to hold multiple compressed files.
• The compress/gzip package’s Writer type adds a Reset so it may be reused.
• The compress/zlib package’s Writer type adds a Reset so it may be reused.
• The container/heap package adds a Fix method to provide a more efficient way to update an item’s position in the heap.
• The container/list package adds the MoveBefore and MoveAfter methods, which implement the obvious rearrangement.
• The crypto/cipher package adds the new GCM mode (Galois Counter Mode), which is almost always used with AES encryption.
• The crypto/md5 package adds a new Sum function to simplify hashing without sacrificing performance.
• Similarly, the crypto/sha1 package adds a new Sum function.
• Also, the crypto/sha256 package adds Sum256 and Sum224 functions.
• Finally, the crypto/sha512 package adds Sum512 and Sum384 functions.
• The crypto/x509 package adds support for reading and writing arbitrary extensions.
• The crypto/tls package adds support for TLS 1.1, 1.2 and AES-GCM.
• The database/sql package adds a SetMaxOpenConns method on DB to limit the number of open connections to the database.
• The encoding/csv package now always allows trailing commas on fields.
• The encoding/gob package now treats channel and function fields of structures as if they were unexported, even if they are not. That is, it ignores them completely. Previously they would trigger an error, which could cause unexpected compatibility problems if an embedded structure added such a field. The package also now supports the generic BinaryMarshaler and BinaryUnmarshaler interfaces of the encoding package described above.
• The encoding/json package now will always escape ampersands as “\u0026” when printing strings. It will now accept but correct invalid UTF-8 in Marshal (such input was previously rejected). Finally, it now supports the generic encoding interfaces of the encoding package described above.
• The encoding/xml package now allows attributes stored in pointers to be marshaled. It also supports the generic encoding interfaces of the encoding package described above through the new Marshaler, Unmarshaler, and related MarshalerAttr and UnmarshalerAttr interfaces. The package also adds a Flush method to the Encoder type for use by custom encoders. See the documentation for EncodeToken to see how to use it.
• The flag package now has a Getter interface to allow the value of a flag to be retrieved. Due to the Go 1 compatibility guidelines, this method cannot be added to the existing Value interface, but all the existing standard flag types implement it. The package also now exports the CommandLine flag set, which holds the flags from the command line.
• The go/ast package’s SliceExpr struct has a new boolean field, Slice3, which is set to true when representing a slice expression with three indices (two colons). The default is false, representing the usual two-index form.
• The go/build package adds the AllTags field to the Package type, to make it easier to process build tags.
• The image/draw package now exports an interface, Drawer, that wraps the standard Draw method. The Porter-Duff operators now implement this interface, in effect binding an operation to the draw operator rather than providing it explicitly. Given a paletted image as its destination, the new FloydSteinberg implementation of the Drawer interface will use the Floyd-Steinberg error diffusion algorithm to draw the image. To create palettes suitable for such processing, the new Quantizer interface represents implementations of quantization algorithms that choose a palette given a full-color image. There are no implementations of this interface in the library.
• The image/gif package can now create GIF files using the new Encode and EncodeAll functions. Their options argument allows specification of an image Quantizer to use; if it is nil, the generated GIF will use the Plan9 color map (palette) defined in the new image/color/palette package. The options also specify a Drawer to use to create the output image; if it is nil, Floyd-Steinberg error diffusion is used.
• The Copy method of the io package now prioritizes its arguments differently. If one argument implements WriterTo and the other implements ReaderFrom, Copy will now invoke WriterTo to do the work, so that less intermediate buffering is required in general.
• The net package requires cgo by default because the host operating system must in general mediate network call setup. On some systems, though, it is possible to use the network without cgo, and useful to do so, for instance to avoid dynamic linking. The new build tag netgo (off by default) allows the construction of a net package in pure Go on those systems where it is possible.
• The net package adds a new field DualStack to the Dialer struct for TCP connection setup using a dual IP stack as described in RFC 6555.
• The net/http package will no longer transmit cookies that are incorrect according to RFC 6265. It just logs an error and sends nothing. Also, the net/http package’s ReadResponse function now permits the *Request parameter to be nil, whereupon it assumes a GET request. Finally, an HTTP server will now serve HEAD requests transparently, without the need for special casing in handler code. While serving a HEAD request, writes to a Handler’s ResponseWriter are absorbed by the Server and the client receives an empty body as required by the HTTP specification.
• The os/exec package’s Cmd.StdinPipe method returns an io.WriteCloser, but has changed its concrete implementation from *os.File to an unexported type that embeds *os.File, and it is now safe to close the returned value. Before Go 1.2, there was an unavoidable race that this change fixes. Code that needs access to the methods of *os.File can use an interface type assertion, such as wc.(interface{ Sync() error }).
• The runtime package relaxes the constraints on finalizer functions in SetFinalizer: the actual argument can now be any type that is assignable to the formal type of the function, as is the case for any normal function call in Go.
• The sort package has a new Stable function that implements stable sorting. It is less efficient than the normal sort algorithm, however.
• The strings package adds an IndexByte function for consistency with the bytes package.
• The sync/atomic package adds a new set of swap functions that atomically exchange the argument with the value stored in the pointer, returning the old value. The functions are SwapInt32, SwapInt64, SwapUint32, SwapUint64, SwapUintptr, and SwapPointer, which swaps an unsafe.Pointer.
• The syscall package now implements Sendfile for Darwin.
• The testing package now exports the TB interface. It records the methods in common with the T and B types, to make it easier to share code between tests and benchmarks. Also, the AllocsPerRun function now quantizes the return value to an integer (although it still has type float64), to round off any error caused by initialization and make the result more repeatable.
• The text/template package now automatically dereferences pointer values when evaluating the arguments to “escape” functions such as “html”, to bring the behavior of such functions in agreement with that of other printing functions such as “printf”.
• In the time package, the Parse function and Format method now handle time zone offsets with seconds, such as in the historical date “1871-01-01T05:33:02+00:34:08”. Also, pattern matching in the formats for those routines is stricter: a non-lowercase letter must now follow the standard words such as “Jan” and “Mon”.
• The unicode package adds In, a nicer-to-use but equivalent version of the original IsOneOf, to see whether a character is a member of a Unicode category.